cpg_conversion.hpp

Go to the documentation of this file.

 
#ifndef _CPG_CONVERSION_HPP
#define _CPG_CONVERSION_HPP
 
#ifndef TBB_SUPPRESS_DEPRECATED_MESSAGES
    #define TBB_SUPPRESS_DEPRECATED_MESSAGES 1
#endif // end of TBB_SUPPRESS_DEPRECATED_MESSAGES
 
#ifndef NOMINMAX
#define NOMINMAX
#endif
 
#ifdef _MSVC_LANG  
    #if _MSVC_LANG < 201703L
        #error This libary requires C++17 Standard (Visual Studio 2017).
    #endif
#else
 
    #if __cplusplus < 201703
        #error This library requires C++17 Standard (GNU g++ version 8.0 or clang++ version 8.0 above)
    #endif // end of __cplusplus 
 
#endif // end of _MSVC_LANG
 
#include <string>
#include <iostream>
#include <clocale>
#include <cstring>
#include <type_traits>
#include <windows.h>
 
namespace cpg
{
    namespace conversion
    {
        inline void load_default_locale(bool ShowLocaleName = false)
        {
            // GetSystemDefaultLocaleName function :
            // https://goo.gl/WLLSG3
 
            // allocate buffer to hold locale name
            std::wstring locale_name(LOCALE_NAME_MAX_LENGTH, L'\0');
 
            int locale_legnth =
                GetSystemDefaultLocaleName(
                    &locale_name[0],
                    LOCALE_NAME_MAX_LENGTH);
 
            // if failed to get locale name, then just return
            if (locale_legnth == 0) return;
 
            // trim trailing buffer
            if(locale_name[locale_legnth] == L'\0')
                locale_name = locale_name.substr(0, locale_legnth-1);
                      
            // https://goo.gl/1A2Hh4
            // set locale of the process or thread
            _wsetlocale(LC_ALL, locale_name.c_str());
 
            if(ShowLocaleName)
                std::wcout << L"locale name: " 
                    << locale_name << std::endl;
        }
    
        inline std::string wstring_to_string(const std::wstring& wstr, 
            unsigned int codepage = CP_UTF8)
        {
            if (wstr.empty()) return "";
 
            // https://goo.gl/acoQBt
            int str_len = WideCharToMultiByte(
                codepage,
                0, // dwFlag
                wstr.c_str(),
                (int)wstr.size(), NULL, 0, NULL, NULL);
 
            // if failed to compute the byte count of the string
            if (str_len == 0) return "";
 
            // prepare a string buffer to
            // hold the converted string
            // do not +1 to str_len,
            // because std::string manages terminating null
            std::string str(str_len, '\0');
 
            int converted = WideCharToMultiByte(
                codepage, 0, wstr.c_str(), (int)wstr.size(),
                &str[0], str_len, NULL, NULL);
 
            return (converted == 0 ? "": str);
        }
 
        inline std::wstring string_to_wstring(const std::string& str, 
            unsigned int codepage = CP_UTF8)
        {
            if (str.empty()) return L"";
 
            // https://goo.gl/upmy99
            // Compute the character length of the string
            int wstr_len = MultiByteToWideChar(
                codepage, 0, str.c_str(), (int)str.size(), NULL, 0);
 
            // if failed to compute the character length
            if (wstr_len == 0) return L"";
 
            // prepare buffer to hold converted string
            // do not +1 to utf16_len, because std::wstring
            // manages terminating null internally
            std::wstring wstr(wstr_len, L'\0');
 
            int converted = MultiByteToWideChar(
                codepage, 0, str.c_str(), (int)str.size(),
                &wstr[0], wstr_len);
 
            return (converted == 0 ? L"": wstr);
        }
 
        inline std::string utf16_to_utf8(const std::wstring& utf16str)
        {
            if (utf16str.empty()) return "";
            return wstring_to_string(utf16str, CP_UTF8);
        }
 
        inline std::wstring utf8_to_utf16(const std::string& utf8str)
        {
            if (utf8str.empty()) 
                return L"";
            return 
                string_to_wstring(utf8str, CP_UTF8);           
        }
 
        inline std::string utf16_to_utf8(const wchar_t* utf16str)
        {
            if (utf16str == nullptr) return "";
 
            // count of character of UTF16 string
            int utf16_len = (int)wcslen(utf16str);
            if (utf16_len < 1) return "";
 
            return utf16_to_utf8(std::wstring(utf16str));
        }
 
        inline std::wstring utf8_to_utf16(const char* utf8str)
        {
            // if utf8str is nullptr, return empty string L""
            if (utf8str == nullptr) return L"";
 
            // count of byte of the string to be converted
            int utf8str_len = (int)strlen(utf8str);
            if (utf8str_len < 1) return L"";
 
            return utf8_to_utf16(std::string(utf8str));
        }
 
        inline char utf16_to_utf8(const wchar_t utf16_char)
        {
            wchar_t src_str[] = {utf16_char, L'\0'};
            auto rlt = utf16_to_utf8(std::wstring(src_str));
            return (rlt.empty() ? '\0': rlt[0]);
        }
 
        inline wchar_t utf8_to_utf16(const char utf8_char)
        {
           char src_str[] = {utf8_char, '\0'};
           auto rlt = utf8_to_utf16(std::string(src_str));
           return (rlt.empty() ? L'\0': rlt[0]);
        }
 
 
        inline std::wstring windows_codepage_to_utf16(const std::string& codepage_string)
        {
            return string_to_wstring(codepage_string, CP_ACP);
        }
 
        inline std::string utf16_to_windows_codepage(const std::wstring& utf16_string)
        {
            return wstring_to_string(utf16_string, CP_ACP);
        }
 
        inline std::wstring windows_codepage_to_utf16(const char* codepage_string)
        {
            if(codepage_string==nullptr) return L"";
            if(strlen(codepage_string)<1) return L"";
 
            return string_to_wstring(std::string(codepage_string), CP_ACP);
        }
 
        inline std::string utf16_to_windows_codepage(const wchar_t* utf16_string)
        {
            if(utf16_string==nullptr) return "";
            if(wcslen(utf16_string)<1) return "";
 
            return wstring_to_string(std::wstring(utf16_string), CP_ACP);
        }
 
        inline std::string windows_codepage_to_utf8(const std::string& codepage_string)
        {
            auto utf16_str = windows_codepage_to_utf16(codepage_string);
            
            return (utf16_str.empty() ? "": utf16_to_utf8(utf16_str));
        }
 
        inline std::string windows_codepage_to_utf8(const char* codepage_string)
        {
            if(codepage_string == nullptr) return "";
            if(strlen(codepage_string) < 1) return "";
 
            return windows_codepage_to_utf8(std::string(codepage_string));
        }
 
        inline std::string utf8_to_windows_codepage(const std::string& utf8_string)
        {
            auto utf16_str = utf8_to_utf16(utf8_string);
            
            return (utf16_str.empty() ? "": utf16_to_windows_codepage(utf16_str));
        }
 
        inline std::string utf8_to_windows_codepage(const char* utf8_string)
        {
            if(utf8_string==nullptr) return "";
            if(strlen(utf8_string) < 1) return "";
 
            return utf8_to_windows_codepage(std::string(utf8_string));
        }
 
        template<typename TargetCharType, typename SourceCharType>
        decltype(auto) 
        source_to_target(const std::basic_string<SourceCharType>& str)
        {
            if constexpr(std::is_same_v<TargetCharType, SourceCharType>)
            {
                return str;
            }
            else if constexpr(std::is_same_v<SourceCharType, char>)
            {
                return utf8_to_utf16(str);
            }
            else
            {
                return utf16_to_utf8(str);
            }
        } 
 
        inline std::string smart_encode(const char* arg)
        {
            #ifdef _MSC_VER
                return { arg };
            #else
                return conversion::utf8_to_windows_codepage(arg);
            #endif 
        }
 
        inline std::string smart_encode(const wchar_t* arg)
        {
            return conversion::utf16_to_windows_codepage(arg);
        }
        
    } // end of namespace conversion
 
} // end of namespace cpg
 
#endif // end of file _CPG_CONVERSION_HPP