option_schema.h

#ifndef INICPP_OPTION_SCHEMA_H
#define INICPP_OPTION_SCHEMA_H

#include <functional>
#include <iostream>
#include <string>
#include <vector>

#include "dll.h"
#include "exception.h"
#include "option.h"
#include "types.h"

namespace inicpp
{
    class option_schema_params_base
    {
    public:
        virtual ~option_schema_params_base()
        {
        }
        std::string name;
        item_requirement requirement = item_requirement::mandatory;
        option_item type = option_item::single;
        std::string default_value = "";
        std::string comment = "";
    };


    template <typename ArgType> class option_schema_params : public option_schema_params_base
    {
    public:
        virtual ~option_schema_params()
        {
        }
        std::function<bool(ArgType)> validator = nullptr;
    };


    class option;


    class INICPP_API option_schema
    {
    private:
        option_type type_;
        std::unique_ptr<option_schema_params_base> params_;

        template <typename ValueType>
        std::unique_ptr<option_schema_params_base> copy_schema(const std::unique_ptr<option_schema_params_base> &opt)
        {
            option_schema_params<ValueType> *ptr = dynamic_cast<option_schema_params<ValueType> *>(&*opt);
            // call copy constructor of option_schema_params<ValueType>
            auto new_schema_value = std::make_unique<option_schema_params<ValueType>>(*ptr);
            return std::move(new_schema_value);
        }

        void validate_option_items(option &opt) const;

        template <typename ValueType>
        void validate_typed_option_items(const std::vector<ValueType> &items, const std::string &option_name) const
        {
            for (const auto &item : items) {
                option_schema_params<ValueType> *ptr = dynamic_cast<option_schema_params<ValueType> *>(&*params_);
                if (ptr != nullptr && ptr->validator != nullptr && !ptr->validator(item)) {
                    throw validation_exception("Option '" + option_name + "' - validation failed");
                }
            }
        }

        void parse_option_items(option &opt) const;

        template <typename ValueType>
        std::vector<ValueType> parse_typed_option_items(const std::vector<std::string> &items,
            std::function<ValueType(const std::string &, const std::string &)> parser,
            const std::string &option_name) const
        {
            std::vector<ValueType> typed_items;
            for (const auto &item : items) {
                typed_items.push_back(parser(item, option_name));
            }
            return typed_items;
        }

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

        template <typename ArgType> option_schema(const option_schema_params<ArgType> &arguments)
        {
            type_ = get_option_enum_type<ArgType>();
            if (type_ == option_type::invalid_e) {
                throw invalid_type_exception("Invalid schema type");
            }

            params_ = std::make_unique<option_schema_params<ArgType>>(arguments);
        }

        const std::string &get_name() const;
        option_type get_type() const;
        bool is_list() const;
        const std::string &get_default_value() const;
        bool is_mandatory() const;
        const std::string &get_comment() const;

        void validate_option(option &opt) const;

        std::ostream &write_additional_info(std::ostream &os) const;
        INICPP_API friend std::ostream &operator<<(std::ostream &os, const option_schema &opt_schema);
    };

    INICPP_API std::ostream &operator<<(std::ostream &os, const option_schema &opt_schema);
}

#endif