config.h

#ifndef INICPP_CONFIG_H
#define INICPP_CONFIG_H

#include <iostream>
#include <map>
#include <vector>

#include "dll.h"
#include "exception.h"
#include "option.h"
#include "schema.h"
#include "section.h"


namespace inicpp
{
    class schema;
    template <typename Element> class config_iterator;


    class INICPP_API config
    {
    private:
        using sections_vector = std::vector<std::shared_ptr<section>>;
        using sections_map = std::map<std::string, std::shared_ptr<section>>;
        using sections_map_pair = std::pair<std::string, std::shared_ptr<section>>;

        sections_vector sections_;
        sections_map sections_map_;

        friend class config_iterator<section>;
        friend class config_iterator<const section>;

    public:
        using iterator = config_iterator<section>;
        using const_iterator = config_iterator<const section>;

        config();
        config(const config &source);
        config &operator=(const config &source);
        config(config &&source);
        config &operator=(config &&source);

        void add_section(const section &sect);
        void add_section(const std::string &section_name);
        void remove_section(const std::string &section_name);

        void add_option(const std::string &section_name, const option &opt);
        template <typename ValueType>
        void add_option(const std::string &section_name, const std::string &option_name, ValueType value)
        {
            auto sect_it = sections_map_.find(section_name);
            if (sect_it != sections_map_.end()) {
                option opt(option_name);
                opt.set<ValueType>(value);
                sect_it->second->add_option(opt);
            } else {
                throw not_found_exception(section_name);
            }
        }

        void remove_option(const std::string &section_name, const std::string &option_name);

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

        void validate(const schema &schm, schema_mode mode);

        bool operator==(const config &other) const;
        bool operator!=(const config &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 config &conf);
    };

    INICPP_API std::ostream &operator<<(std::ostream &os, const config &conf);


    template <typename Element> class config_iterator : public std::iterator<std::random_access_iterator_tag, Element>
    {
    private:
        config &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;

        config_iterator() = delete;
        config_iterator(const config_iterator &src) = default;
        config_iterator &operator=(const config_iterator &source) = default;
        config_iterator(config_iterator &&src) = default;
        config_iterator &operator=(config_iterator &&source) = default;

        config_iterator(config &source, size_t position) : container_(source), position_(position)
        {
        }
        config_iterator(config &source) : config_iterator(source, 0)
        {
        }

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

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

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

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

#endif