Str.h

Go to the documentation of this file.

// Str.h
//
// Copyright (c) 2009, 2014, 2016 Michael Imamura.
//
// Licensed under GrokkSoft HoverRace SourceCode License v1.0(the "License");
// you may not use this file except in compliance with the License.
//
// A copy of the license should have been attached to the package from which
// you have taken this file. If you can not find the license you can not use
// this file.
//
//
// The author makes no representations about the suitability of
// this software for any purpose.  It is provided "as is" "AS IS",
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied.
//
// See the License for the specific language governing permissions
// and limitations under the License.

#pragma once

#include "OS.h"

#if defined(_WIN32) && defined(HR_ENGINE_SHARED)
#   ifdef MR_ENGINE
#       define MR_DllDeclare   __declspec( dllexport )
#   else
#       define MR_DllDeclare   __declspec( dllimport )
#   endif
#else
#   define MR_DllDeclare
#endif

namespace HoverRace {
namespace Util {

namespace Str {

MR_DllDeclare wchar_t *Utf8ToWide(const char *s);
MR_DllDeclare char *WideToUtf8(const wchar_t *ws);

MR_DllDeclare void Append(std::string &dest, const std::string &src,
    size_t len);
MR_DllDeclare size_t Assign(std::string &dest, const std::string &src,
    size_t len);

class MR_DllDeclare UW
{
    wchar_t *cs;
public:
    UW(const char *s = nullptr) noexcept : cs(Utf8ToWide(s)) { }
    explicit UW(const std::string &s) noexcept : cs(Utf8ToWide(s.c_str())) { }
    ~UW() noexcept { free(cs); }
    operator const wchar_t*() const noexcept { return cs; }
    operator const std::wstring() const { return cs; }
};

class MR_DllDeclare WU
{
    char *cs;
public:
    WU(const wchar_t *ws = nullptr) noexcept : cs(WideToUtf8(ws)) { }
    explicit WU(const std::wstring &s) noexcept : cs(WideToUtf8(s.c_str())) { }
    ~WU() noexcept { free(cs); }
    operator const char*() const noexcept { return cs; }
    operator const std::string() const { return cs; }
};

// Convert UTF-8 to path_t.
#ifdef WITH_WIDE_PATHS
    inline OS::path_t UP(const char *s = nullptr) noexcept { return OS::path_t((const wchar_t*)Str::UW(s)); }
    inline OS::path_t UP(const std::string &s) noexcept { return OS::path_t((const wchar_t*)Str::UW(s)); }
#else
    inline OS::path_t UP(const char *s = nullptr) noexcept { return OS::path_t(s); }
    inline OS::path_t UP(const std::string &s) noexcept { return OS::path_t(s); }
#endif

// Convert path_t to UTF-8.
class MR_DllDeclare PU
{
#   ifdef WITH_WIDE_PATHS
        WU cs;
    public:
        explicit PU(const OS::path_t &path) noexcept : cs(path.wstring()) { }
        operator const char*() const noexcept { return (const char*)cs; }
        operator const std::string() const { return std::string((const char*)cs); }
#   else
        std::string cs;
    public:
        explicit PU(const OS::path_t &path) noexcept : cs(path.string()) { }
        operator const char*() const noexcept { return cs.c_str(); }
        operator const std::string() const { return cs; }
#   endif
};

    // Convert wide strings to path_t.
#ifdef WITH_WIDE_PATHS
    inline OS::path_t WP(const wchar_t *s = nullptr) noexcept { return OS::path_t(s); }
    inline OS::path_t WP(const std::wstring &s) noexcept { return OS::path_t(s); }
#else
    inline OS::path_t WP(const wchar_t *s=NULL) noexcept { return OS::path_t((const char*)Str::WU(s)); }
    inline OS::path_t WP(const std::wstring &s) noexcept { return OS::path_t((const char*)Str::WU(s)); }
#endif

// Convert path_t to wide string.
class MR_DllDeclare PW
{
#   ifdef WITH_WIDE_PATHS
        std::wstring cs;
        public:
            explicit PW(const OS::path_t &path) noexcept : cs(path.wstring()) { }
            operator const wchar_t*() const noexcept { return cs.c_str(); }
            operator const std::wstring() const { return cs; }
#   else
        UW cs;
        public:
            explicit PW(const OS::path_t &path) noexcept : cs(path.string()) { }
            operator const wchar_t*() const noexcept { return (const wchar_t*)cs; }
            operator const std::wstring() const { return cs; }
#   endif
};

class MR_DllDeclare Lua
{
public:
    explicit Lua(const std::string &s) : s(s) { }

public:
    std::ostream &StreamOut(std::ostream &os) const;

private:
    std::string s;
};

inline std::ostream &operator<<(std::ostream &os, const Lua &lua)
{
    return lua.StreamOut(os);
}

}  // namespace Str

}  // namespace Util
}  // namespace HoverRace

#undef MR_DllDeclare