String.hpp

#pragma once
 
#include <algorithm>
#include <codecvt>
#include <locale>
#include <optional>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
namespace PixelBullet
{
    template <typename T>
    struct is_optional : std::false_type
    {
    };
    template <typename T>
    struct is_optional<std::optional<T>> : std::true_type
    {
    };
    template <typename T>
    inline constexpr bool is_optional_v = is_optional<T>::value;
 
    class String
    {
    public:
        static std::string ConvertUtf8(const std::wstring_view& wstr)
        {
            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
            return converter.to_bytes(wstr.data(), wstr.data() + wstr.size());
        }
 
        static std::wstring ConvertUtf16(const std::string_view& str)
        {
            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
            return converter.from_bytes(str.data(), str.data() + str.size());
        }
 
        static std::vector<std::string> Split(const std::string& str, char sep)
        {
            std::vector<std::string> tokens;
            std::istringstream iss(str);
            std::string token;
            while (std::getline(iss, token, sep))
            {
                tokens.emplace_back(token);
            }
            return tokens;
        }
 
        static bool StartsWith(std::string_view str, std::string_view token)
        {
            return str.substr(0, token.size()) == token;
        }
 
        static bool Contains(std::string_view str, std::string_view token) noexcept
        {
            return str.find(token) != std::string::npos;
        }
 
        static std::string_view Trim(std::string_view str, std::string_view whitespace = " \t\n\r")
        {
            const size_t first = str.find_first_not_of(whitespace);
            if (first == std::string::npos)
            {
                return "";
            }
            const size_t last = str.find_last_not_of(whitespace);
            return str.substr(first, last - first + 1);
        }
 
        static std::string ReplaceFirst(std::string_view source, std::string_view search, std::string_view replace)
        {
            std::string result(source);
            size_t pos = result.find(search);
            if (pos != std::string::npos)
            {
                result.replace(pos, search.size(), replace);
            }
            return result;
        }
 
        template <typename T>
        static std::string To(T val)
        {
            if constexpr (std::is_same_v<std::string, T> || std::is_same_v<const char*, T>)
            {
                return val;
            }
            else if constexpr (std::is_enum_v<T>)
            {
                using Underlying = typename std::underlying_type<T>::type;
                return std::to_string(static_cast<Underlying>(val));
            }
            else if constexpr (std::is_same_v<bool, T>)
            {
                return val ? "true" : "false";
            }
            else if constexpr (std::is_same_v<std::nullptr_t, T>)
            {
                return "null";
            }
            else if constexpr (is_optional_v<T>)
            {
                return val.has_value() ? To(*val) : "null";
            }
            else if constexpr (std::is_same_v<char, T>)
            {
                return std::string(1, val);
            }
            else
            {
                return std::to_string(val);
            }
        }
 
        template <typename T>
        static T From(const std::string& str)
        {
            if constexpr (std::is_same_v<std::string, T>)
            {
                return str;
            }
            else if constexpr (std::is_enum_v<T>)
            {
                using Underlying = typename std::underlying_type<T>::type;
                return static_cast<T>(From<Underlying>(str));
            }
            else if constexpr (std::is_same_v<bool, T>)
            {
                return str == "true" || str == "1";
            }
            else if constexpr (is_optional_v<T>)
            {
                using Base = typename T::value_type;
                std::istringstream iss(str);
                Base value;
                if ((iss >> value).fail())
                {
                    return std::nullopt;
                }
                return value;
            }
            else
            {
                std::istringstream iss(str);
                long double temp;
                iss >> temp;
                return static_cast<T>(temp);
            }
        }
    };
} // namespace PixelBullet