Utils.h

#pragma once
 
#include "Property.h"
#include <map>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace sw
{
    class Utils
    {
    private:
        Utils() = delete; // 删除构造函数
 
        template <typename T, typename = void>
        struct _HasToString : std::false_type {
        };
 
        template <typename T>
        struct _HasToString<
            T,
            decltype(void(std::declval<T>().ToString()))> : std::true_type {
        };
 
    public:
        static std::wstring ToWideStr(const std::string &str, bool utf8 = false);
 
        static std::string ToMultiByteStr(const std::wstring &wstr, bool utf8 = false);
 
        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 inline T Max(const T &a, const T &b)
        {
            return a > b ? a : b;
        }
 
        template <typename T>
        static constexpr inline T Min(const T &a, const T &b)
        {
            return a < b ? a : b;
        }
 
        template <typename... Args>
        static inline std::wstring BuildStr(const Args &...args)
        {
            std::wstringstream wss;
            int _[]{(Utils::_BuildStr(wss, args), 0)...};
            return wss.str();
        }
 
    private:
        template <typename T>
        static inline typename std::enable_if<!_IsProperty<T>::value && !_HasToString<T>::value, void>::type
        _BuildStr(std::wostream &wos, const T &arg)
        {
            wos << arg;
        }
 
        template <typename T>
        static inline typename std::enable_if<!_IsProperty<T>::value && _HasToString<T>::value, void>::type
        _BuildStr(std::wostream &wos, const T &arg)
        {
            Utils::_BuildStr(wos, arg.ToString());
        }
 
        template <typename T>
        static inline typename std::enable_if<_IsProperty<T>::value, void>::type
        _BuildStr(std::wostream &wos, const T &prop)
        {
            Utils::_BuildStr(wos, prop.Get());
        }
 
        static inline void _BuildStr(std::wostream &wos, bool b)
        {
            wos << (b ? L"true" : L"false");
        }
 
        static inline void _BuildStr(std::wostream &wos, const char *str)
        {
            wos << Utils::ToWideStr(str);
        }
 
        static inline void _BuildStr(std::wostream &wos, const std::string &str)
        {
            wos << Utils::ToWideStr(str);
        }
 
        template <typename T>
        static inline 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", ";
                Utils::_BuildStr(wos, *it);
            }
            wos << L"]";
        }
 
        template <typename TKey, typename TVal>
        static inline 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", ";
                Utils::_BuildStr(wos, it->first);
                wos << L":";
                Utils::_BuildStr(wos, it->second);
            }
            wos << L"}";
        }
 
        template <typename TKey, typename TVal>
        static inline 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", ";
                Utils::_BuildStr(wos, it->first);
                wos << L":";
                Utils::_BuildStr(wos, it->second);
            }
            wos << L"}";
        }
    };
}