config.hxx

#pragma once
 
#include <StormByte/config/alias.hxx>
#include <StormByte/config/item/value.hxx>
#include <StormByte/config/item/comment.hxx>
#include <StormByte/config/item/group.hxx>
#include <StormByte/config/item/list.hxx>
#include <StormByte/config/type.hxx>
#include <StormByte/serializable.hxx>
 
namespace StormByte::Config {
    class STORMBYTE_CONFIG_PUBLIC Config {
        friend class StormByte::Serializable<Config>;
        public:
            Config();
 
            Config(const Config& config)                            = default;
 
            Config(Config&& config) noexcept                        = default;
 
            Config& operator=(const Config& config)                 = default;
 
            Config& operator=(Config&& config) noexcept             = default;
 
            virtual ~Config()                                       = default;
 
            inline Item::Base&                                      operator[](const std::string& path) {
                return m_root.operator[](path);
            }
 
            inline const Item::Base&                                operator[](const std::string& path) const {
                return m_root.operator[](path);
            }
 
            Item::Base&                                             operator[](const size_t& index) {
                return m_root[index];
            }
 
            const Item::Base&                                       operator[](const size_t& index) const {
                return m_root[index];
            }
 
            inline bool                                             operator==(const Config& config) const noexcept {
                return m_root == config.m_root;
            }
 
            inline bool                                             operator!=(const Config& config) const noexcept {
                return !operator==(config);
            }
 
            /* INPUT */
            Config&                                                 operator<<(const Config& source);
 
            void                                                    operator<<(std::istream& istream); // 1
 
            void                                                    operator<<(const std::string& str); // 2
 
            friend STORMBYTE_CONFIG_PUBLIC Config&                  operator>>(std::istream& istream, Config& file); // 3
 
            friend STORMBYTE_CONFIG_PUBLIC Config&                  operator>>(const std::string& str, Config& file); // 4
            
            /* OUTPUT */
            Config&                                                 operator>>(Config& dest) const;
 
            std::ostream&                                           operator>>(std::ostream& ostream) const; // 5
 
            std::string&                                            operator>>(std::string& str) const; // 6
 
            friend STORMBYTE_CONFIG_PUBLIC std::ostream&            operator<<(std::ostream& ostream, const Config& file); // 7
 
            friend STORMBYTE_CONFIG_PUBLIC std::string&             operator<<(std::string&, const Config&); // 8
 
                                                                    operator std::string() const;
 
            inline Item::Base&                                      Add(const Item::Base& item) {
                return m_root.Add(item.Clone(), m_on_existing_action);
            }
 
            Item::Base&                                             Add(Item::Base&& item) {
                return m_root.Add(std::move(item.Move()), m_on_existing_action);
            }
 
            inline void                                             Clear() noexcept {
                m_root.Clear();
            }
 
            inline bool                                             Exists(const std::string& path) const {
                return m_root.Exists(path);
            }
 
            inline void                                             Remove(const std::string& path) {
                m_root.Remove(path);
            }
 
            inline void                                             Remove(const size_t& path) {
                m_root.Remove(path);
            }
 
            constexpr void                                          OnExistingAction(const OnExistingAction& on_existing) {
                m_on_existing_action = on_existing;
            }
 
            constexpr void                                          OnParseFailure(OnFailureHook hook) {
                m_on_parse_failure_hook = hook;
            }
 
            constexpr void                                          AddHookBeforeRead(HookFunction hook) {
                m_before_read_hooks.push_back(hook);
            }
            
            constexpr void                                          AddHookAfterRead(HookFunction hook) {
                m_after_read_hooks.push_back(hook);
            }
 
            constexpr virtual size_t                                Size() const noexcept {
                return m_root.Size();
            }
 
            inline virtual size_t                                   Count() const noexcept {
                return m_root.Count();
            }
 
            constexpr std::span<Item::Base::PointerType>            Items() noexcept {
                return m_root.Items();
            }
 
            constexpr std::span<const Item::Base::PointerType>      Items() const noexcept {
                return m_root.Items();
            }
 
        protected:
            Item::Group                                             m_root;                             
 
            HookFunctions                                           m_before_read_hooks;                
            HookFunctions                                           m_after_read_hooks;                 
            OptionalFailureHook                                     m_on_parse_failure_hook;            
 
            StormByte::Config::OnExistingAction                     m_on_existing_action;               
    };
    STORMBYTE_CONFIG_PUBLIC Config&                                 operator>>(std::istream& istream, Config& file);
 
    STORMBYTE_CONFIG_PUBLIC Config&                                 operator>>(const std::string& str, Config& file);
 
    STORMBYTE_CONFIG_PUBLIC std::ostream&                           operator<<(std::ostream& ostream, const Config& file);
 
    STORMBYTE_CONFIG_PUBLIC std::string&                            operator<<(std::string& str, const Config& file);
}