section.h

#ifndef INICPP_SECTION_H
#define INICPP_SECTION_H

#include <algorithm>
#include <iostream>
#include <iterator>
#include <map>
#include <vector>

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

namespace inicpp
{
    class section_schema;
    template <typename Element> class section_iterator;


    class INICPP_API section
    {
    private:
        using options_vector = std::vector<std::shared_ptr<option>>;
        using options_map = std::map<std::string, std::shared_ptr<option>>;
        using options_map_pair = std::pair<std::string, std::shared_ptr<option>>;

        options_vector options_;
        options_map options_map_;
        std::string name_;

        friend class section_iterator<option>;
        friend class section_iterator<const option>;

    public:
        using iterator = section_iterator<option>;
        using const_iterator = section_iterator<const option>;

        section() = delete;
        section(const section &source);
        section &operator=(const section &source);
        section(section &&source);
        section &operator=(section &&source);

        section(const std::string &name);

        const std::string &get_name() const;

        template <typename ValueType> void add_option(const std::string &option_name, ValueType value)
        {
            auto add_it = options_map_.find(option_name);
            if (add_it == options_map_.end()) {
                std::shared_ptr<option> opt = std::make_shared<option>(option_name);
                opt->set<ValueType>(value);
                options_.push_back(opt);
                options_map_.insert(options_map_pair(opt->get_name(), opt));
            } else {
                throw ambiguity_exception(option_name);
            }
        }
        void add_option(const option &opt);
        void remove_option(const std::string &option_name);

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

        void validate(const section_schema &sect_schema, schema_mode mode);

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

        iterator begin();
        iterator end();
        const_iterator begin() const;
        const_iterator end() const;
        const_iterator cbegin() const;
        const_iterator cend() const;

        INICPP_API friend std::ostream &operator<<(std::ostream &os, const section &sect);
    };

    INICPP_API std::ostream &operator<<(std::ostream &os, const section &sect);

    template <typename Element> class section_iterator : public std::iterator<std::random_access_iterator_tag, Element>
    {
    private:
        section &container_;
        size_t position_;

    public:
        using typename std::iterator<std::random_access_iterator_tag, Element>::reference;
        using typename std::iterator<std::random_access_iterator_tag, Element>::pointer;

        section_iterator() = delete;
        section_iterator(const section_iterator &source) = default;
        section_iterator &operator=(const section_iterator &source) = default;
        section_iterator(section_iterator &&source) = default;
        section_iterator &operator=(section_iterator &&source) = default;

        section_iterator(section &source, size_t position) : container_(source), position_(position)
        {
        }
        section_iterator(section &source) : section_iterator(source, 0)
        {
        }

        section_iterator &operator++()
        {
            ++position_;
            return *this;
        }
        section_iterator operator++(int)
        {
            section_iterator old(*this);
            operator++();
            return old;
        }

        bool operator==(const section_iterator &second) const
        {
            return &container_ == &second.container_ && position_ == second.position_;
        }
        bool operator!=(const section_iterator &second) const
        {
            return !(*this == second);
        }

        reference operator*()
        {
            return *container_.options_.at(position_);
        }

        pointer operator->()
        {
            return &(operator*());
        }
    };
}

#endif