Charset.hpp

#pragma once
#include <samchon/API.hpp>

#include <string>
#include <codecvt>
#include <samchon/WeakString.hpp>

#ifdef _WIN32
#include <atlstr.h>
#endif

namespace samchon
{
namespace library
{
    class Charset
    {
    public:
        enum : int
        {
            MULTIBYTE = 4,
            UTF8 = 8
        };

        static auto toMultibyte(const std::string &source) -> std::string
        {
            std::wstring &wstr = toUnicode(source, UTF8);
            std::string &dest = toMultibyte(wstr);

            return dest;
        };

        static auto toMultibyte(const std::wstring &source) -> std::string
        {
#ifdef _WIN32
            int len = WideCharToMultiByte(CP_ACP, 0, &source[0], -1, NULL, 0, NULL, NULL);
            std::string str(len, 0);
            WideCharToMultiByte(CP_ACP, 0, &source[0], -1, &str[0], len, NULL, NULL);

            return str;
#else
            using namespace std;
            typedef codecvt<wchar_t, char, mbstate_t> codecvt_t;

            locale &loc = locale("");

            codecvt_t const& codecvt = use_facet<codecvt_t>(loc);
            mbstate_t state = mbstate_t();
            vector<char> buf(source.size() * codecvt.max_length());
            wchar_t const* in_next = source.c_str();
            char* out_next = &buf[0];

            codecvt_base::result r =
                codecvt.out
                (
                    state,
                    source.c_str(), source.c_str() + source.size(), in_next,
                    &buf[0], &buf[0] + buf.size(), out_next
                );

            if (r == codecvt_base::error)
                throw runtime_error("can't convert wstring to string");

            return string(buf.begin(), buf.end());
#endif
        };

        static auto toUTF8(const std::string &source) -> std::string
        {
            std::wstring &wstr = toUnicode(source, MULTIBYTE);
            std::string &dest = toUTF8(wstr);

            if (dest.back() == NULL)
                dest.pop_back();

            return dest;
        };

        static auto toUTF8(const std::wstring &source) -> std::string
        {
#ifdef _WIN32
            int len = WideCharToMultiByte(CP_UTF8, 0, &source[0], -1, NULL, 0, NULL, NULL);
            std::string str(len, 0);
            WideCharToMultiByte(CP_UTF8, 0, &source[0], -1, &str[0], len, NULL, NULL);

            return str;
#else
            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> utf8Converter;
            return utf8Converter.to_bytes(source);
#endif
        };

        static auto toUnicode(const std::string &source, int charset) -> std::wstring
        {
#ifdef _WIN32
            if (charset == MULTIBYTE)
            {
                int nLen = MultiByteToWideChar(CP_ACP, 0, &source[0], (int)source.size(), NULL, NULL);
                std::wstring wstr(nLen, 0);
                MultiByteToWideChar(CP_ACP, 0, &source[0], (int)source.size(), &wstr[0], nLen);

                return wstr;
            }
            else if (charset == UTF8)
            {
                int nLen = MultiByteToWideChar(CP_UTF8, 0, &source[0], (int)source.size(), NULL, NULL);
                std::wstring wstr(nLen, 0);
                MultiByteToWideChar(CP_UTF8, 0, &source[0], (int)source.size(), &wstr[0], nLen);

                return wstr;
        }
            else
                return L"";

#else
            using namespace std;

            if (charset == MULTIBYTE)
            {
                locale &loc = locale("");

                typedef codecvt<wchar_t, char, mbstate_t> codecvt_t;
                codecvt_t const& codecvt = use_facet<codecvt_t>(loc);
                mbstate_t state = mbstate_t();
                vector<wchar_t> buf(source.size());
                char const* in_next = source.c_str();
                wchar_t* out_next = &buf[0];

                codecvt_base::result r =
                    codecvt.in
                    (
                        state,
                        source.c_str(), source.c_str() + source.size(), in_next,
                        &buf[0], &buf[0] + buf.size(), out_next
                    );

                if (r == codecvt_base::error)
                    throw runtime_error("can't convert string to wstring");

                return wstring(buf.begin(), buf.end());
            }
            else if (charset == UTF8)
            {
                std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> utf8Converter;
                wstring &wstr = move(utf8Converter.from_bytes(source));

                return wstr;
            }
            else
                return L"";
#endif
        };
    };
};
};