option.h

#ifndef INICPP_OPTION_H
#define INICPP_OPTION_H

#include <cctype>
#include <iostream>
#include <memory>
#include <vector>

#include "dll.h"
#include "exception.h"
#include "option_schema.h"
#include "string_utils.h"
#include "types.h"
#include "types.h"


namespace inicpp
{
    class option_schema;


    class option_holder
    {
    public:
        virtual ~option_holder()
        {
        }
    };


    template <typename ValueType> class option_value : public option_holder
    {
    public:
        option_value(ValueType value) : value_(value)
        {
        }
        virtual ~option_value()
        {
        }

        ValueType get()
        {
            return value_;
        }
        void set(ValueType value)
        {
            value_ = value;
        }

    private:
        ValueType value_;
    };


    namespace
    {
        template <typename ActualType, typename ReturnType> class convertor
        {
        public:
            static ReturnType get_converted_value(const std::unique_ptr<option_holder> &value)
            {
                option_value<ActualType> *ptr = dynamic_cast<option_value<ActualType> *>(&*value);
                if (ptr == nullptr) {
                    throw bad_cast_exception("Cannot cast to requested type");
                }
                try {
                    return static_cast<ReturnType>(ptr->get());
                } catch (std::runtime_error &e) {
                    throw bad_cast_exception(e.what());
                }
            }
        };

        template <typename ActualType> class convertor<ActualType, string_ini_t>
        {
        public:
            static string_ini_t get_converted_value(const std::unique_ptr<option_holder> &value)
            {
                option_value<ActualType> *ptr = dynamic_cast<option_value<ActualType> *>(&*value);
                if (ptr == nullptr) {
                    throw bad_cast_exception("Cannot cast to requested type");
                }
                return inistd::to_string(ptr->get());
            }
        };
    } // anonymous namespace

    class INICPP_API option
    {
    private:
        std::string name_;
        option_type type_;
        std::vector<std::unique_ptr<option_holder>> values_;
        std::shared_ptr<option_schema> option_schema_;

        template <typename ValueType> void copy_option(const std::unique_ptr<option_holder> &opt)
        {
            option_value<ValueType> *ptr = dynamic_cast<option_value<ValueType> *>(&*opt);
            auto new_option_value = std::make_unique<option_value<ValueType>>(ptr->get());
            values_.push_back(std::move(new_option_value));
        }

        template <typename ValueType>
        bool compare_option(
            const std::unique_ptr<option_holder> &local, const std::unique_ptr<option_holder> &remote) const
        {
            option_value<ValueType> *loc = dynamic_cast<option_value<ValueType> *>(&*local);
            option_value<ValueType> *rem = dynamic_cast<option_value<ValueType> *>(&*remote);
            return loc->get() == rem->get();
        }

        template <typename ReturnType>
        ReturnType convert_single_value(option_type source_type, const std::unique_ptr<option_holder> &value) const
        {
            switch (source_type) {
            case option_type::boolean_e: return convertor<boolean_ini_t, ReturnType>::get_converted_value(value); break;
            case option_type::enum_e: return convertor<enum_ini_t, ReturnType>::get_converted_value(value); break;
            case option_type::float_e: return convertor<float_ini_t, ReturnType>::get_converted_value(value); break;
            case option_type::signed_e: return convertor<signed_ini_t, ReturnType>::get_converted_value(value); break;
            case option_type::string_e: {
                option_value<string_ini_t> *ptr = dynamic_cast<option_value<string_ini_t> *>(&*value);
                if (ptr == nullptr) {
                    throw bad_cast_exception("Cannot cast to requested type");
                }

                // We have string, so try to parse it
                try {
                    return string_utils::parse_string<ReturnType>(ptr->get(), get_name());
                } catch (invalid_type_exception &e) {
                    throw bad_cast_exception(e.what());
                }
            } break;
            case option_type::unsigned_e:
                return convertor<unsigned_ini_t, ReturnType>::get_converted_value(value);
                break;
            case option_type::invalid_e:
            default:
                // never reached
                throw invalid_type_exception("Invalid option type");
                break;
            }
        }

    public:
        option() = delete;
        option(const option &source);
        option &operator=(const option &source);
        option(option &&source);
        option &operator=(option &&source);

        option(const std::string &name, const std::string &value = "");
        option(const std::string &name, const std::vector<std::string> &values);

        const std::string &get_name() const;

        option_type get_type() const;
        bool is_list() const;

        template <typename ValueType> void set(ValueType value)
        {
            this->operator=(value);
        }
        option &operator=(boolean_ini_t arg);
        option &operator=(signed_ini_t arg);
        option &operator=(unsigned_ini_t arg);
        option &operator=(float_ini_t arg);
        option &operator=(const char *arg);
        option &operator=(string_ini_t arg);
        option &operator=(enum_ini_t arg);

        template <typename ReturnType> ReturnType get() const
        {
            if (values_.empty()) {
                throw not_found_exception(0);
            }

            // Get the value and try to convert it
            return convert_single_value<ReturnType>(type_, values_[0]);
        }

        template <typename ValueType> void set_list(const std::vector<ValueType> &list)
        {
            values_.clear();
            type_ = get_option_enum_type<ValueType>();
            for (const auto &item : list) {
                add_to_list(item);
            }
        }

        template <typename ReturnType> std::vector<ReturnType> get_list() const
        {
            if (values_.empty()) {
                throw not_found_exception(0);
            }
            std::vector<ReturnType> results;
            for (const auto &value : values_) {
                results.push_back(convert_single_value<ReturnType>(type_, value));
            }

            return results;
        }

        template <typename ValueType> void add_to_list(ValueType value)
        {
            if (get_option_enum_type<ValueType>() != type_) {
                throw bad_cast_exception("Cannot cast to requested type");
            }
            auto new_option_value = std::make_unique<option_value<ValueType>>(value);
            values_.push_back(std::move(new_option_value));
        }

        template <typename ValueType> void add_to_list(ValueType value, size_t position)
        {
            if (get_option_enum_type<ValueType>() != type_) {
                throw bad_cast_exception("Cannot cast to requested type");
            }
            if (position > values_.size()) {
                throw not_found_exception(position);
            }
            auto new_option_value = std::make_unique<option_value<ValueType>>(value);
            values_.insert(values_.begin() + position, std::move(new_option_value));
        }

        template <typename ValueType> void remove_from_list(ValueType value)
        {
            if (get_option_enum_type<ValueType>() != type_) {
                throw bad_cast_exception("Cannot cast to requested type");
            }
            for (auto it = values_.cbegin(); it != values_.cend(); ++it) {
                option_value<ValueType> *ptr = dynamic_cast<option_value<ValueType> *>(&*(*it));
                if (ptr->get() == value) {
                    values_.erase(it);
                    break;
                }
            }
        }

        void remove_from_list_pos(size_t position);

        void validate(const option_schema &opt_schema);

        bool operator==(const option &other) const;
        bool operator!=(const option &other) const;

        INICPP_API friend std::ostream &operator<<(std::ostream &os, const option &opt);
    };

    INICPP_API std::ostream &operator<<(std::ostream &os, const option &opt);
}

#endif