string.hpp

#pragma once
 
#include <sstream>
#include <string>
#include <regex>
#include <algorithm>
#include <iterator>
 
#ifdef _MSC_VER
#  ifndef NOMINMAX
#    define NOMINMAX
#  endif
#  include <Windows.h>
#elif __GNUC__
#  include <codecvt>
#  include <locale>
 
#endif
 
#include "global.hpp"
 
namespace Cvb
{

  CVB_BEGIN_INLINE_NS
 
#if defined _WIN32 && defined(UNICODE)
 
  using String = std::wstring;
 
  using StringStream = std::wstringstream;
 
  using Char = wchar_t;
 
  using Regex = std::wregex;
 
#  define CVB_LIT(STR) L##STR
#else


  using String = std::string;


  using StringStream = std::stringstream;


  using Char = char;


  using Regex = std::regex;

#  define CVB_LIT(STR) STR
 
#endif
 
  namespace Internal
  {
 
    inline bool IsAccessToken(const String &provider)
    {
      return provider.front() == CVB_LIT('{') && provider.back() == CVB_LIT('}');
    }
 
    inline std::string CastToAscii(const String &native)
    {
      std::string ascii;
      std::transform(native.begin(), native.end(), std::back_inserter(ascii),
                     [](String::value_type ch) { return static_cast<char>(ch); });
      return ascii;
    }
 
    inline std::string WideCharStrToUTF8(const std::wstring &inWStr)
    {
      if (!inWStr.capacity())
        return "";
      std::string retval;
 
#ifdef _WIN32
      auto call = [&inWStr](char *str, int pos) -> int {
        return WideCharToMultiByte(CP_UTF8, 0, inWStr.data(), -1, str, pos, nullptr, nullptr);
      };
      int n = call(nullptr, 0);
      if (n <= 0)
      {
        // if error happens, do ugly returning of the raw content (encoding ignorant)
        std::string str(inWStr.length(), 0);
        std::transform(inWStr.begin(), inWStr.end(), str.begin(), [](wchar_t c) { return (char)c; });
        return std::string("error in utf8-conversion of the following error message: ") + str
               + std::string(" (unencoded)");
      }
 
      retval.resize(n - static_cast<int>(1));
 
      if (call(&retval[0], n) == 0)
      {
        // if error happens, do ugly returning of the raw content (encoding ignorant)
        std::string str(inWStr.length(), 0);
        std::transform(inWStr.begin(), inWStr.end(), str.begin(), [](wchar_t c) { return (char)c; });
        return std::string("error in utf8-conversion of the following error message: ") + str
               + std::string(" (unencoded)");
      }
 
      return retval;
 
#else
      std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
      return converter.to_bytes(inWStr.data());
#endif
    }
 
    inline bool IsASCII(const std::string &str)
    {
      for (const unsigned char& c : str)
      {
        if (c > 0x7F)
          return false;
      }
      return true;
    }
 
    inline std::string ToUTF8(const std::string& str)
    {
#ifdef _WIN32
      if (GetACP() == CP_UTF8 || IsASCII(str))
        return str;
 
      // Convert ANSI -> UTF-16 -> UTF-8
      int wlen = MultiByteToWideChar(CP_ACP, 0, str.data(), static_cast<int>(str.size()), nullptr, 0);
      if (wlen == 0)
        return str; // to avoid throwing we return what we have -> may look ugly
 
      std::wstring wstr(wlen, 0);
      MultiByteToWideChar(CP_ACP, 0, str.data(), static_cast<int>(str.size()), &wstr[0], wlen);
 
      return WideCharStrToUTF8(wstr);
#else
      return str;
#endif
    }
 
    inline std::string ToUTF8(const std::wstring& str)
    {
      return WideCharStrToUTF8(str);
    }
 
  }  // namespace Internal
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb