section_schema.h

#ifndef INICPP_SECTION_SCHEMA_H
#define INICPP_SECTION_SCHEMA_H

#include <iostream>
#include <vector>

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


namespace inicpp
{
    struct section_schema_params {
        std::string name;
        item_requirement requirement = item_requirement::mandatory;
        std::string comment;
    };


    class section;


    class INICPP_API section_schema
    {
    private:
        using opt_schema_vector = std::vector<std::shared_ptr<option_schema>>;
        using opt_schema_map = std::map<std::string, std::shared_ptr<option_schema>>;
        using opt_schema_map_pair = std::pair<std::string, std::shared_ptr<option_schema>>;

        std::string name_;
        item_requirement requirement_;
        std::string comment_;

        opt_schema_vector options_;
        opt_schema_map options_map_;

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

        section_schema(const section_schema_params &arguments);

        const std::string &get_name() const;
        bool is_mandatory() const;
        const std::string &get_comment() const;

        void add_option(const option_schema &opt);
        template <typename ArgType> void add_option(const option_schema_params<ArgType> &arguments)
        {
            auto add_it = options_map_.find(arguments.name);
            if (add_it == options_map_.end()) {
                std::shared_ptr<option_schema> add = std::make_shared<option_schema>(arguments);
                options_.push_back(add);
                options_map_.insert(opt_schema_map_pair(add->get_name(), add));
            } else {
                throw ambiguity_exception(arguments.name);
            }
        }
        void remove_option(const std::string &name);

        size_t size() const;
        option_schema &operator[](size_t index);
        const option_schema &operator[](size_t index) const;
        option_schema &operator[](const std::string &option_name);
        const option_schema &operator[](const std::string &option_name) const;
        bool contains(const std::string &option_name) const;

        void validate_section(section &sect, schema_mode mode) const;

        std::ostream &write_additional_info(std::ostream &os) const;
        std::ostream &write_section_name(std::ostream &os) const;
        INICPP_API friend std::ostream &operator<<(std::ostream &os, const section_schema &sect_schema);
    };

    INICPP_API std::ostream &operator<<(std::ostream &os, const section_schema &sect_schema);
}

#endif