types.h

#ifndef INICPP_TYPES_H
#define INICPP_TYPES_H

#include <stdexcept>
#include <string>
#include <type_traits>


namespace inicpp
{
    class internal_enum_type
    {
    public:
        internal_enum_type() : internal_enum_type("")
        {
        }
        internal_enum_type(const std::string &value) : data_(value)
        {
        }
        internal_enum_type(const char *value) : data_(value)
        {
        }
        internal_enum_type(const internal_enum_type &other)
        {
            this->operator=(other);
        }
        explicit internal_enum_type(bool)
        {
            throw std::runtime_error("");
        }
        explicit internal_enum_type(int64_t)
        {
            throw std::runtime_error("");
        }
        explicit internal_enum_type(uint64_t)
        {
            throw std::runtime_error("");
        }
        explicit internal_enum_type(double)
        {
            throw std::runtime_error("");
        }

        internal_enum_type &operator=(const internal_enum_type &other)
        {
            data_ = other.data_;
            return *this;
        }
        operator std::string() const
        {
            return data_;
        }
        operator double() const
        {
            throw std::runtime_error("Enum type cannot be converted to double");
        }
        bool operator==(const internal_enum_type &other)
        {
            return data_ == other.data_;
        }
        bool operator!=(const internal_enum_type &other)
        {
            return !(*this == other);
        }
        bool operator<(const internal_enum_type &other)
        {
            return data_ < other.data_;
        }

    private:
        std::string data_;
    };


    enum class option_type : char { boolean_e, signed_e, unsigned_e, float_e, enum_e, string_e, invalid_e };

    // modern C++11 way of typedef
    using boolean_ini_t = bool;
    using signed_ini_t = int64_t;
    using unsigned_ini_t = uint64_t;
    using float_ini_t = double;
    using enum_ini_t = internal_enum_type;
    using string_ini_t = std::string;

    enum class option_item : bool { single, list };

    enum class item_requirement : bool { mandatory, optional };

    enum class schema_mode : bool { strict, relaxed };

    template <typename ValueType> option_type get_option_enum_type()
    {
        if (std::is_same<ValueType, boolean_ini_t>::value) {
            return option_type::boolean_e;
        } else if (std::is_same<ValueType, signed_ini_t>::value) {
            return option_type::signed_e;
        } else if (std::is_same<ValueType, unsigned_ini_t>::value) {
            return option_type::unsigned_e;
        } else if (std::is_same<ValueType, float_ini_t>::value) {
            return option_type::float_e;
        } else if (std::is_same<ValueType, string_ini_t>::value) {
            return option_type::string_e;
        } else if (std::is_same<ValueType, enum_ini_t>::value) {
            return option_type::enum_e;
        } else {
            return option_type::invalid_e;
        }
    }
}

#endif // INICPP_TYPES_H