StringUtils.hpp

Go to the documentation of this file.

#pragma once
#ifndef ENIGMA_STRING_UTILS_H
#define ENIGMA_STRING_UTILS_H
 
#include <Core/Types.hpp> // Enigma Types
 
#include <algorithm> // std::all_of
#include <codecvt>   // helps converting between UTF-X strings
#include <locale>    // required for Linux & Darwin causes error: �wstring_convert� is not a member of �std�
#include <sstream>   // std::stringstream
#include <string>    // std::string, std::string_view
#include <utility>   // std::transform
#include <vector>
 
NS_ENIGMA_BEGIN
/*
*   UTF-8 & UTF-16 std::string Utility
*/
class StringUtils final {
  ENIGMA_STATIC_CLASS(StringUtils);
 
public:
  /*
    *       Removes leading and trailing spaces from a string
    */
  template<typename StringType>
  static void Trim(StringType& str) {
    TrimLeft(str);
    TrimRight(str);
  }
 
 
  /*
    *   Trim string from left
    */
  template<typename StringType>
  static void TrimLeft(StringType& str) {
    if (std::empty(str)) return;
    str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](const auto& c) {
                return !std::isspace(c);
              }));
  }
 
 
  /*
    *   Trim string from right
    */
  template<typename StringType>
  static void TrimRight(StringType& str) {
    if (std::empty(str)) return;
    str.erase(std::find_if(str.rbegin(), str.rend(), [](const auto& c) {
                return !std::isspace(c);
              }).base(),
              str.end());
  }
 
 
  /*
    *   Lowercase a string
    */
  template<typename StringType>
  static void Lower(StringType& str) {
    std::transform(str.begin(), str.end(), str.begin(), [](const auto& c) {
      return static_cast<typename StringType::value_type>(std::tolower(c));
    });
  }
 
 
  /*
    *   Lowercase a string and return a copy of it
    */
  template<typename StringType>
  static auto LowerCopy(const StringType& str) {
    StringType cstr = str;
    std::transform(cstr.begin(), cstr.end(), cstr.begin(), [](const auto& c) {
      return static_cast<typename StringType::value_type>(std::tolower(c));
    });
    return cstr;
  }
 
 
  /*
    *   Uppercase a string
    */
  template<typename StringType>
  static void Upper(StringType& str) {
    std::transform(str.begin(), str.end(), str.begin(), [](const auto& c) {
      return static_cast<typename StringType::value_type>(std::toupper(c));
    });
  }
 
 
  /*
    *   Uppercase a string and return a copy of it
    */
  template<typename StringType>
  static auto UpperCopy(const StringType& str) {
    StringType cstr = str;
    std::transform(cstr.begin(), cstr.end(), cstr.begin(), [](const auto& c) {
      return static_cast<typename StringType::value_type>(std::toupper(c));
    });
    return cstr;
  }
 
 
  /*
    *   Check if a string starts with a prefix
    */
  template<typename StringType>
  static bool StartsWith(const StringType& str, const StringType& prefix) {
    return str.size() >= prefix.size() && str.compare(0, prefix.size(), prefix) == 0;
  }
 
 
  /*
    *   Check if a string ends with a suffix
    */
  template<typename StringType>
  static bool EndsWith(const StringType& str, const StringType& suffix) {
    return str.size() >= suffix.size() && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
  }
 
  /*
    *   Splits string at a delimiter into parts
    */
  template<typename StringType>
  static std::vector<StringType> Split(const StringType& str, const typename std::string::value_type delimiter) {
    std::vector<StringType> parts{};
    std::stringstream ss(str);
    std::string line{};
    while (std::getline(ss, line, delimiter)) {
      parts.push_back(line);
    }
    return parts;
  }
 
  /*
    *   Check if a string contains another
    */
  template<typename StringType>
  static bool Contains(const StringType& str, const StringType& other) {
    return str.find(other) != StringType::npos;
  }
 
 
  /*
    *   Converts UTF-8 std::string to UTF-16 std::wstring
    */
  static std::wstring StringToWString(const std::string& str) {
    using convert_type = std::codecvt_utf8<wchar_t>;
    static std::wstring_convert<convert_type, wchar_t> converter;
    return converter.from_bytes(str);
  }
 
 
  /*
    *   Converts UTF-16 std::wstring to UTF-8 std::string
    */
  static std::string WStringToString(const std::wstring& wstr) {
    using convert_type = std::codecvt_utf8<wchar_t>;
    static std::wstring_convert<convert_type, wchar_t> converter;
    return converter.to_bytes(wstr);
  }
 
 
  /*
    *   Convert string to any other simple type
    */
  template<typename T, typename StringType>
  static T To(const StringType& str) {
    T t{};
    std::basic_stringstream<typename StringType::value_type> ss(str);
    ss >> t;
    return t;
  }
 
#if 0
 
    /*
    *   Cleanup a string (remove string from string)
    */
    static std::string Cleanup(const std::string& expr, const std::string& remove)
    {
        const std::size_t N = expr.size();
        const std::size_t K = remove.size();
        std::string result(N, '\000');
        std::size_t srcIndex = 0;
        std::size_t dstIndex = 0;
        while (srcIndex < N)
        {
            std::size_t matchIndex = 0;
            while (matchIndex < K - 1 && srcIndex + matchIndex < N - 1 && expr[srcIndex + matchIndex] == remove[matchIndex])
            {
                matchIndex++;
                if (matchIndex == K - 1)
                    srcIndex += matchIndex;
            }
            result[dstIndex++] = expr[srcIndex] == '"' ? '\'' : expr[srcIndex];
            srcIndex++;
        }
        result.resize(dstIndex, '\000'); // resize to fit string after removing other str
        return result;
    }
    static std::wstring Cleanup(const std::wstring& expr, const std::wstring& remove)
    {
        const std::size_t N = expr.size();
        const std::size_t K = remove.size();
        std::wstring result(N, L'\000');
        std::size_t srcIndex = 0;
        std::size_t dstIndex = 0;
        while (srcIndex < N)
        {
            std::size_t matchIndex = 0;
            while (matchIndex < K - 1 && srcIndex + matchIndex < N - 1 && expr[srcIndex + matchIndex] == remove[matchIndex])
                matchIndex++;
            if (matchIndex == K - 1)
                srcIndex += matchIndex;
            result[dstIndex++] = expr[srcIndex] == '"' ? '\'' : expr[srcIndex];
            srcIndex++;
        }
        result.resize(dstIndex, L'\000'); // resize to fit string after removing other str
        return result;
    }
 
    template <std::size_t N>
    struct CleanupResult // wrapper to keep data variable alive in the stack after going out of scope of Cleanup function
    {
        char data[N];
    };
    template <std::size_t N, std::size_t K>
    static auto Cleanup(const char(&expr)[N], const char(&remove)[K])
    {
        CleanupResult<N> result{};
        std::size_t srcIndex = 0;
        std::size_t dstIndex = 0;
        //while constexpr (srcIndex < N)
        while (srcIndex < N)
        {
            std::size_t matchIndex = 0;
            while (matchIndex < K - 1 && srcIndex + matchIndex < N - 1 && expr[srcIndex + matchIndex] == remove[matchIndex])
                matchIndex++;
            if (matchIndex == K - 1)
                srcIndex += matchIndex;
            result.data[dstIndex++] = expr[srcIndex] == '"' ? '\'' : expr[srcIndex];
            srcIndex++;
        }
        return result;
    }
#endif
};
NS_ENIGMA_END
 
#endif // !ENIGMA_STRING_UTILS_H