Converters.h

#pragma once
 
#include "IValueConverter.h"
#include "Utils.h"
#include <cwchar>
 
// clang-format off
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4996) // make sscanf great again
#endif
 
// clang-format on
 
namespace sw
{
    template <typename TBaseConverter, typename = void>
    class ReverseConverter;
 
    template <typename TBaseConverter>
    class ReverseConverter<
        TBaseConverter,
        typename std::enable_if<
            std::is_base_of<
                IValueConverter<
                    typename std::decay<typename TBaseConverter::TSourceParam>::type,
                    typename std::decay<typename TBaseConverter::TTargetParam>::type>,
                TBaseConverter>::value>::type>
        : public IValueConverter<
              typename std::decay<typename TBaseConverter::TTargetParam>::type,
              typename std::decay<typename TBaseConverter::TSourceParam>::type>
    {
    public:
        using TSourceParam = typename TBaseConverter::TTargetParam;
        using TTargetParam = typename TBaseConverter::TSourceParam;
        using TSource      = typename std::decay<TSourceParam>::type;
        using TTarget      = typename std::decay<TTargetParam>::type;
 
        template <typename... Args>
        ReverseConverter(Args &&...args)
            : baseConverter(std::forward<Args>(args)...)
        {
        }
        virtual TTarget Convert(TSourceParam source) override
        {
            return baseConverter.ConvertBack(source);
        }
        virtual TSource ConvertBack(TTargetParam target) override
        {
            return baseConverter.Convert(target);
        }
 
    private:
        TBaseConverter baseConverter;
    };
 
    /*================================================================================*/
 
    template <typename TSource, typename TTarget, typename = void>
    class NumericConverter;
 
    template <typename TSource, typename TTarget>
    class NumericConverter<TSource,
                           TTarget,
                           typename std::enable_if<std::is_arithmetic<TSource>::value && std::is_arithmetic<TTarget>::value>::type>
        : public IValueConverter<TSource, TTarget>
    {
    public:
        virtual TTarget Convert(TSource source) override
        {
            return static_cast<TTarget>(source);
        }
        virtual TSource ConvertBack(TTarget target) override
        {
            return static_cast<TSource>(target);
        }
    };
 
    using IntToFloatConverter  = NumericConverter<int, float>;
    using IntToDoubleConverter = NumericConverter<int, double>;
    using FloatToIntConverter  = NumericConverter<float, int>;
    using DoubleToIntConverter = NumericConverter<double, int>;
 
    /*================================================================================*/
 
    template <typename T, typename = void>
    class NumericNegationConverter;
 
    template <typename T>
    class NumericNegationConverter<T, typename std::enable_if<std::is_arithmetic<T>::value>::type>
        : public IValueConverter<T, T>
    {
    public:
        virtual T Convert(T source) override
        {
            return -source;
        }
        virtual T ConvertBack(T target) override
        {
            return -target;
        }
    };
 
    /*================================================================================*/
 
    class BoolNegationConverter : public IValueConverter<bool, bool>
    {
    public:
        virtual bool Convert(bool source) override
        {
            return !source;
        }
        virtual bool ConvertBack(bool target) override
        {
            return !target;
        }
    };
 
    template <typename TSource, typename = void>
    class NumericToBoolConverter;
 
    template <typename TSource>
    class NumericToBoolConverter<TSource, typename std::enable_if<std::is_arithmetic<TSource>::value>::type>
        : public IValueConverter<TSource, bool>
    {
    public:
        virtual bool Convert(TSource source) override
        {
            return source != static_cast<TSource>(0);
        }
        virtual TSource ConvertBack(bool target) override
        {
            return target ? static_cast<TSource>(1) : static_cast<TSource>(0);
        }
    };
 
    template <typename TTarget, typename = void>
    class BoolToNumericConverter;
 
    template <typename TTarget>
    class BoolToNumericConverter<TTarget, typename std::enable_if<std::is_arithmetic<TTarget>::value>::type>
        : public IValueConverter<bool, TTarget>
    {
    public:
        virtual TTarget Convert(bool source) override
        {
            return source ? static_cast<TTarget>(1) : static_cast<TTarget>(0);
        }
        virtual bool ConvertBack(TTarget target) override
        {
            return target != static_cast<TTarget>(0);
        }
    };
 
    using BoolToIntConverter = BoolToNumericConverter<int>;
    using IntToBoolConverter = NumericToBoolConverter<int>;
 
    /*================================================================================*/
 
    template <typename TSource, typename TTarget, typename = void>
    class EnumToNumericConverter;
 
    template <typename TSource, typename TTarget>
    class EnumToNumericConverter<TSource,
                                 TTarget,
                                 typename std::enable_if<std::is_enum<TSource>::value && std::is_arithmetic<TTarget>::value>::type>
        : public IValueConverter<TSource, TTarget>
    {
    public:
        virtual TTarget Convert(TSource source) override
        {
            return static_cast<TTarget>(source);
        }
        virtual TSource ConvertBack(TTarget target) override
        {
            return static_cast<TSource>(target);
        }
    };
 
    template <typename TSource, typename TTarget, typename = void>
    class NumericToEnumConverter;
 
    template <typename TSource, typename TTarget>
    class NumericToEnumConverter<TSource,
                                 TTarget,
                                 typename std::enable_if<std::is_arithmetic<TSource>::value && std::is_enum<TTarget>::value>::type>
        : public IValueConverter<TSource, TTarget>
    {
    public:
        virtual TTarget Convert(TSource source) override
        {
            return static_cast<TTarget>(source);
        }
        virtual TSource ConvertBack(TTarget target) override
        {
            return static_cast<TSource>(target);
        }
    };
 
    template <typename TEnum>
    using EnumToIntConverter = EnumToNumericConverter<TEnum, int>;
 
    template <typename TEnum>
    using IntToEnumConverter = NumericToEnumConverter<int, TEnum>;
 
    /*================================================================================*/
 
    class IntToStringConverter : public IValueConverter<int, std::wstring>
    {
    public:
        explicit IntToStringConverter(int defaultValue = 0)
            : defaultValue(defaultValue)
        {
        }
        virtual std::wstring Convert(int source) override
        {
            return std::to_wstring(source);
        }
        virtual int ConvertBack(const std::wstring &target) override
        {
            int result;
            bool success = std::swscanf(target.c_str(), L"%d", &result) == 1;
            return success ? result : defaultValue;
        }
 
    private:
        int defaultValue;
    };
 
    class FloatToStringConverter : public IValueConverter<float, std::wstring>
    {
    public:
        explicit FloatToStringConverter(float defaultValue = 0.0f)
            : defaultValue(defaultValue)
        {
        }
        virtual std::wstring Convert(float source) override
        {
            std::wstring result(32, L'\0');
            int len = std::swprintf(&result[0], result.size(), L"%g", source);
            result.resize(len > 0 ? len : 0);
            return result;
        }
        virtual float ConvertBack(const std::wstring &target) override
        {
            float result;
            bool success = std::swscanf(target.c_str(), L"%f", &result) == 1;
            return success ? result : defaultValue;
        }
 
    private:
        float defaultValue;
    };
 
    class DoubleToStringConverter : public IValueConverter<double, std::wstring>
    {
    public:
        explicit DoubleToStringConverter(double defaultValue = 0.0)
            : defaultValue(defaultValue)
        {
        }
        virtual std::wstring Convert(double source) override
        {
            std::wstring result(32, L'\0');
            int len = std::swprintf(&result[0], result.size(), L"%g", source);
            result.resize(len > 0 ? len : 0);
            return result;
        }
        virtual double ConvertBack(const std::wstring &target) override
        {
            double result;
            bool success = std::swscanf(target.c_str(), L"%lf", &result) == 1;
            return success ? result : defaultValue;
        }
 
    private:
        double defaultValue;
    };
 
    class StringToIntConverter : public IValueConverter<std::wstring, int>
    {
    public:
        explicit StringToIntConverter(int defaultValue = 0)
            : defaultValue(defaultValue)
        {
        }
        virtual int Convert(const std::wstring &source) override
        {
            int result;
            bool success = std::swscanf(source.c_str(), L"%d", &result) == 1;
            return success ? result : defaultValue;
        }
        virtual std::wstring ConvertBack(int target) override
        {
            return std::to_wstring(target);
        }
 
    private:
        int defaultValue;
    };
 
    class StringToFloatConverter : public IValueConverter<std::wstring, float>
    {
    public:
        explicit StringToFloatConverter(float defaultValue = 0.0f)
            : defaultValue(defaultValue)
        {
        }
        virtual float Convert(const std::wstring &source) override
        {
            float result;
            bool success = std::swscanf(source.c_str(), L"%f", &result) == 1;
            return success ? result : defaultValue;
        }
        virtual std::wstring ConvertBack(float target) override
        {
            std::wstring result(32, L'\0');
            int len = std::swprintf(&result[0], result.size(), L"%g", target);
            result.resize(len > 0 ? len : 0);
            return result;
        }
 
    private:
        float defaultValue;
    };
 
    class StringToDoubleConverter : public IValueConverter<std::wstring, double>
    {
    public:
        explicit StringToDoubleConverter(double defaultValue = 0.0)
            : defaultValue(defaultValue)
        {
        }
        virtual double Convert(const std::wstring &source) override
        {
            double result;
            bool success = std::swscanf(source.c_str(), L"%lf", &result) == 1;
            return success ? result : defaultValue;
        }
        virtual std::wstring ConvertBack(double target) override
        {
            std::wstring result(32, L'\0');
            int len = std::swprintf(&result[0], result.size(), L"%g", target);
            result.resize(len > 0 ? len : 0);
            return result;
        }
 
    private:
        double defaultValue;
    };
 
    /*================================================================================*/
 
    class IntToAnsiStringConverter : public IValueConverter<int, std::string>
    {
    public:
        explicit IntToAnsiStringConverter(int defaultValue = 0)
            : defaultValue(defaultValue)
        {
        }
        virtual std::string Convert(int source) override
        {
            return std::to_string(source);
        }
        virtual int ConvertBack(const std::string &target) override
        {
            int result;
            bool success = std::sscanf(target.c_str(), "%d", &result) == 1;
            return success ? result : defaultValue;
        }
 
    private:
        int defaultValue;
    };
 
    class FloatToAnsiStringConverter : public IValueConverter<float, std::string>
    {
    public:
        explicit FloatToAnsiStringConverter(float defaultValue = 0.0f)
            : defaultValue(defaultValue)
        {
        }
        virtual std::string Convert(float source) override
        {
            std::string result(32, '\0');
            int len = std::snprintf(&result[0], result.size(), "%g", source);
            result.resize(len > 0 ? len : 0);
            return result;
        }
        virtual float ConvertBack(const std::string &target) override
        {
            float result;
            bool success = std::sscanf(target.c_str(), "%f", &result) == 1;
            return success ? result : defaultValue;
        }
 
    private:
        float defaultValue;
    };
 
    class DoubleToAnsiStringConverter : public IValueConverter<double, std::string>
    {
    public:
        explicit DoubleToAnsiStringConverter(double defaultValue = 0.0)
            : defaultValue(defaultValue)
        {
        }
        virtual std::string Convert(double source) override
        {
            std::string result(32, '\0');
            int len = std::snprintf(&result[0], result.size(), "%g", source);
            result.resize(len > 0 ? len : 0);
            return result;
        }
        virtual double ConvertBack(const std::string &target) override
        {
            double result;
            bool success = std::sscanf(target.c_str(), "%lf", &result) == 1;
            return success ? result : defaultValue;
        }
 
    private:
        double defaultValue;
    };
 
    class AnsiStringToIntConverter : public IValueConverter<std::string, int>
    {
    public:
        explicit AnsiStringToIntConverter(int defaultValue = 0)
            : defaultValue(defaultValue)
        {
        }
        virtual int Convert(const std::string &source) override
        {
            int result;
            bool success = std::sscanf(source.c_str(), "%d", &result) == 1;
            return success ? result : defaultValue;
        }
        virtual std::string ConvertBack(int target) override
        {
            return std::to_string(target);
        }
 
    private:
        int defaultValue;
    };
 
    class AnsiStringToFloatConverter : public IValueConverter<std::string, float>
    {
    public:
        explicit AnsiStringToFloatConverter(float defaultValue = 0.0f)
            : defaultValue(defaultValue)
        {
        }
        virtual float Convert(const std::string &source) override
        {
            float result;
            bool success = std::sscanf(source.c_str(), "%f", &result) == 1;
            return success ? result : defaultValue;
        }
        virtual std::string ConvertBack(float target) override
        {
            std::string result(32, '\0');
            int len = std::snprintf(&result[0], result.size(), "%g", target);
            result.resize(len > 0 ? len : 0);
            return result;
        }
 
    private:
        float defaultValue;
    };
 
    class AnsiStringToDoubleConverter : public IValueConverter<std::string, double>
    {
    public:
        explicit AnsiStringToDoubleConverter(double defaultValue = 0.0)
            : defaultValue(defaultValue)
        {
        }
        virtual double Convert(const std::string &source) override
        {
            double result;
            bool success = std::sscanf(source.c_str(), "%lf", &result) == 1;
            return success ? result : defaultValue;
        }
        virtual std::string ConvertBack(double target) override
        {
            std::string result(32, '\0');
            int len = std::snprintf(&result[0], result.size(), "%g", target);
            result.resize(len > 0 ? len : 0);
            return result;
        }
 
    private:
        double defaultValue;
    };
 
    /*================================================================================*/
 
    class StringToAnsiStringConverter : public IValueConverter<std::wstring, std::string>
    {
    public:
        virtual std::string Convert(const std::wstring &source) override
        {
            return Utils::ToMultiByteStr(source);
        }
        virtual std::wstring ConvertBack(const std::string &target) override
        {
            return Utils::ToWideStr(target);
        }
    };
 
    class AnsiStringToStringConverter : public IValueConverter<std::string, std::wstring>
    {
    public:
        virtual std::wstring Convert(const std::string &source) override
        {
            return Utils::ToWideStr(source);
        }
        virtual std::string ConvertBack(const std::wstring &target) override
        {
            return Utils::ToMultiByteStr(target);
        }
    };
 
    class StringToUtf8StringConverter : public IValueConverter<std::wstring, std::string>
    {
    public:
        virtual std::string Convert(const std::wstring &source) override
        {
            return Utils::ToMultiByteStr(source, true);
        }
        virtual std::wstring ConvertBack(const std::string &target) override
        {
            return Utils::ToWideStr(target, true);
        }
    };
 
    class Utf8StringToStringConverter : public IValueConverter<std::string, std::wstring>
    {
    public:
        virtual std::wstring Convert(const std::string &source) override
        {
            return Utils::ToWideStr(source, true);
        }
        virtual std::string ConvertBack(const std::wstring &target) override
        {
            return Utils::ToMultiByteStr(target, true);
        }
    };
}
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif