Utils.h

#pragma once
 
#include "Internal.h"
#include "Property.h"
#include <map>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace sw
{
    class Utils
    {
    private:
        Utils() = delete;
 
    public:
        static void UseUtf8Encoding(bool useUtf8);
 
        static std::wstring ToWideStr(const std::string &str);
 
        static std::string ToMultiByteStr(const std::wstring &wstr);
 
        static std::wstring ToWideStr(const std::string &str, bool utf8);
 
        static std::string ToMultiByteStr(const std::wstring &wstr, bool utf8);
 
        static std::wstring Trim(const std::wstring &str);
 
        static std::wstring TrimStart(const std::wstring &str);
 
        static std::wstring TrimEnd(const std::wstring &str);
 
        static std::vector<std::wstring> Split(const std::wstring &str, const std::wstring &delimiter);
 
        static std::wstring FormatStr(const wchar_t *fmt, ...);
 
    public:
        template <typename T>
        static constexpr auto Max(T a, T b) noexcept
            -> typename std::enable_if<std::is_scalar<T>::value, T>::type
        {
            return a > b ? a : b;
        }
 
        template <typename T>
        static auto Max(const T &a, const T &b)
            -> typename std::enable_if<!std::is_scalar<T>::value, T>::type
        {
            return a > b ? a : b;
        }
 
        template <typename T>
        static constexpr auto Min(T a, T b) noexcept
            -> typename std::enable_if<std::is_scalar<T>::value, T>::type
        {
            return a < b ? a : b;
        }
 
        template <typename T>
        static auto Min(const T &a, const T &b)
            -> typename std::enable_if<!std::is_scalar<T>::value, T>::type
        {
            return a < b ? a : b;
        }
 
        template <typename... Args>
        static std::wstring BuildStr(const Args &...args)
        {
            std::wstringstream wss;
            int _[]{(_BuildStr(wss, args), 0)...};
            return wss.str();
        }
 
    private:
        template <typename T>
        static auto _BuildStr(std::wostream &wos, const T &arg)
            -> typename std::enable_if<!_IsProperty<T>::value && !_HasToString<T>::value>::type
        {
            wos << arg;
        }
 
        template <typename T>
        static auto _BuildStr(std::wostream &wos, const T &arg)
            -> typename std::enable_if<!_IsProperty<T>::value && _HasToString<T>::value>::type
        {
            _BuildStr(wos, arg.ToString());
        }
 
        template <typename T>
        static auto _BuildStr(std::wostream &wos, const T &prop)
            -> typename std::enable_if<_IsProperty<T>::value>::type
        {
            _BuildStr(wos, prop.Get());
        }
 
        static void _BuildStr(std::wostream &wos, bool b)
        {
            wos << (b ? L"true" : L"false");
        }
 
        static void _BuildStr(std::wostream &wos, const char *str)
        {
            wos << ToWideStr(str);
        }
 
        static void _BuildStr(std::wostream &wos, const std::string &str)
        {
            wos << ToWideStr(str);
        }
 
        template <typename T>
        static void _BuildStr(std::wostream &wos, const std::vector<T> &vec)
        {
            auto beg = vec.begin();
            auto end = vec.end();
            wos << L"[";
            for (auto it = beg; it != end; ++it) {
                if (it != beg)
                    wos << L", ";
                _BuildStr(wos, *it);
            }
            wos << L"]";
        }
 
        template <typename TKey, typename TVal>
        static void _BuildStr(std::wostream &wos, const std::map<TKey, TVal> &map)
        {
            auto beg = map.begin();
            auto end = map.end();
            wos << L"{";
            for (auto it = beg; it != end; ++it) {
                if (it != beg)
                    wos << L", ";
                _BuildStr(wos, it->first);
                wos << L":";
                _BuildStr(wos, it->second);
            }
            wos << L"}";
        }
 
        template <typename TKey, typename TVal>
        static void _BuildStr(std::wostream &wos, const std::unordered_map<TKey, TVal> &map)
        {
            auto beg = map.begin();
            auto end = map.end();
            wos << L"{";
            for (auto it = beg; it != end; ++it) {
                if (it != beg)
                    wos << L", ";
                _BuildStr(wos, it->first);
                wos << L":";
                _BuildStr(wos, it->second);
            }
            wos << L"}";
        }
    };
}