type_converter.h

Go to the documentation of this file.

#pragma once
#include "xml_exception.h"
#include <cstdint>
#include <string>
#include <deque>
#include <forward_list>
#include <vector>
#include <list>
#include <array>
#include <sstream>
#include <cfloat>
#include <algorithm>
#include "commonlib/mathematics/mathfuncs.h"
#include "commonlib/datatypes/stringhelper.h"

BEGIN_NAMESPACE_SERIALIZATION

template <typename T>
struct is_container
{
    static bool const value = false;
};

template <typename T, size_t N>
struct is_container<std::array<T, N>>
{
    static bool const value = true;
};

template <typename... Args>
struct is_container<std::vector<Args...>>
{
    static bool const value = true;
};

template <typename... Args>
struct is_container<std::deque<Args...>>
{
    static bool const value = true;
};

template <typename... Args>
struct is_container<std::list<Args...>>
{
    static bool const value = true;
};

template <typename... Args>
struct is_container<std::forward_list<Args...>>
{
    static bool const value = true;
};

template <typename T>
struct has_back_insert
{
    static bool const value = false;
};

template <typename... Args>
struct has_back_insert<std::vector<Args...>>
{
    static bool const value = true;
};

template <typename... Args>
struct has_back_insert<std::list<Args...>>
{
    static bool const value = true;
};

template <typename... Args>
struct has_back_insert<std::deque<Args...>>
{
    static bool const value = true;
};

template <typename T, typename T2 = void>
struct TypeConverter;

template <>
struct TypeConverter<std::string>
{
    std::string defaultValue = "";

    static std::string toString(const std::string& value)
    {
        return value;
    }

    static std::string convertStringToProperType(const std::string& value)
    {
        return value;
    }
};

template <>
struct TypeConverter<const char*>
{
    std::string defaultValue = "";

    static std::string toString(const char* value)
    {
        return value;
    }

    static std::string convertStringToProperType(const std::string& value)
    {
        return value;
    }
};

template <int N>
struct TypeConverter<char[N]>
{
    std::string defaultValue = "";

    static std::string toString(const char* value)
    {
        return value;
    }

    static std::string convertStringToProperType(const std::string& value)
    {
        return value;
    }
};

template <>
struct TypeConverter<bool>
{
    bool defaultValue = false;

    static std::string toString(const bool value)
    {
        if (value)
            return "True";

        return "False";
    }

    static bool convertStringToProperType(const std::string& value)
    {
        std::string boolString = value;
        std::transform(boolString.begin(), boolString.end(), boolString.begin(), [](char c) {
            return char(tolower(c));
        });

        if (boolString == "true")
            return true;

        if (boolString == "false")
            return false;

        char* pEnd;
        if (!Mathematics::MathFuncs::areSame(strtod(boolString.c_str(), &pEnd), 0.0) && std::string(pEnd).empty())
            return true;

        return false;
    }
};

template <typename T>
struct TypeConverter<T, typename std::enable_if<std::is_floating_point<T>::value && !is_container<T>::value>::type>
{
    T defaultValue = 0.0;

    static void changeDecimalToCLocale(std::string& value)
    {
        const auto decPoint = std::use_facet<std::numpunct<char>>(std::locale(setlocale(LC_NUMERIC, nullptr))).decimal_point();
        for (char& c : value)
        {
            if (c == ',' || c == '.')
            {
                c = decPoint;
                return;
            }
        }
    }

    static std::string toString(const T& value)
    {
        std::stringstream ssFloatingPoint;

        if (std::is_same<T, float>::value)
        {
            ssFloatingPoint.precision(FLT_DIG);
        }
        else
        {
            ssFloatingPoint.precision(DBL_DIG);
        }
        ssFloatingPoint << std::fixed << value;
        return ssFloatingPoint.str();
    }

    static T convertStringToProperType(const std::string& value)
    {
        std::string tempStr(value);
        changeDecimalToCLocale(tempStr);

        if (std::is_same<T, float>::value)
        {
            return static_cast<T>(std::stof(tempStr));
        }
        else
        {
            return static_cast<T>(std::stod(tempStr));
        }
    }
};

template <typename T>
struct TypeConverter<T, typename std::enable_if<std::is_signed<T>::value && std::is_integral<T>::value && !is_container<T>::value>::type>
{
    T defaultValue = 0;

    static std::string toString(const T& value)
    {
        return std::to_string(value);
    }

    static int64_t convertStringToProperType(const std::string& value)
    {
        return std::stoll(value);
    }
};

template <typename T>
struct TypeConverter<T, typename std::enable_if<std::is_unsigned<T>::value && std::is_integral<T>::value && !is_container<T>::value>::type>
{
    T defaultValue = 0;

    static std::string toString(const T& value)
    {
        return std::to_string(value);
    }

    static uint64_t convertStringToProperType(const std::string& value)
    {
        return std::stoull(value);
    }
};

template <typename T, typename T2 = void>
struct ContainerInputIterators;

template <typename T>
struct ContainerInputIterators<T, typename std::enable_if<is_container<T>::value>::type>
{
    static auto begin(const T& container)
    {
        return std::begin(container);
    }

    static auto end(const T& container)
    {
        return std::end(container);
    }
};

template <typename T, typename T2 = void>
struct ContainerOutputIterators;

template <typename T>
struct ContainerOutputIterators<T, typename std::enable_if<is_container<T>::value>::type>
{
    static auto begin(T& container)
    {
        return std::begin(container);
    }

    static auto end(T& container)
    {
        return std::end(container);
    }
};

template <typename IteratorCategory, typename ValueType>
class CustomIteratorTypes
{
public:
    using iterator_category = IteratorCategory;
    using value_type = ValueType;
    using difference_type = std::ptrdiff_t;
    using pointer = ValueType*;
    using reference = ValueType&;
};

template <class T>
struct output_iterator_traits : std::iterator_traits<T>
{
};

template <class Container>
struct output_iterator_traits<std::back_insert_iterator<Container>>
    : CustomIteratorTypes<std::output_iterator_tag, typename Container::value_type>
{
};

END_NAMESPACE_SERIALIZATION