config.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Config.
 *
 * StormByte-Config is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * or later, as published by the Free Software Foundation.
 *
 * StormByte-Config is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with StormByte-Config. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 */
 
#pragma once
 
#include <StormByte/config/alias.hxx>
#include <StormByte/config/item/comment.hxx>
#include <StormByte/config/item/group.hxx>
#include <StormByte/config/item/list.hxx>
#include <StormByte/config/item/value.hxx>
#include <StormByte/config/typedefs.hxx>
 
#include <cstddef>
#include <istream>
#include <ostream>
#include <span>
#include <string>
#include <vector>
 
namespace StormByte::Config {
    namespace Binary {
        class Reader;
        class Writer;
    }
 
    class STORMBYTE_CONFIG_PUBLIC Config {
        friend class Binary::Reader;
        friend class Binary::Writer;
        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);
            }
            Config& operator<<(const Config& source);
 
            void operator<<(std::istream& istream);
 
            void operator<<(const std::string& str);
 
            friend STORMBYTE_CONFIG_PUBLIC Config& operator>>(std::istream& istream, Config& file);
 
            friend STORMBYTE_CONFIG_PUBLIC Config& operator>>(const std::string& str, Config& file);
            Config& operator>>(Config& dest) const;
 
            std::ostream& operator>>(std::ostream& ostream) const;
 
            std::string& operator>>(std::string& str) const;
 
            friend STORMBYTE_CONFIG_PUBLIC std::ostream& operator<<(std::ostream& ostream, const Config& file);
 
            friend STORMBYTE_CONFIG_PUBLIC std::string& operator<<(std::string&, const Config&);
 
            operator std::string() const;
 
            void Save(std::ostream& stream, Mode mode = Mode::Text) const;
 
            static ExpectedConfig Load(std::istream& stream, Mode mode = Mode::Text);
            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 Item::Base& Add(Item::Base::PointerType item) {
                return m_root.Add(item, m_on_existing_action);
            }
 
            inline Item::Base& Add(Item::Base::PointerType item, const StormByte::Config::OnExistingAction& on_existing) {
                return m_root.Add(item, on_existing);
            }
 
            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& index) {
                m_root.Remove(index);
            }
 
            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();
            }
            void OnExistingAction(const OnExistingAction& on_existing) {
                m_on_existing_action = on_existing;
                m_root.SetOnExistingAction(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);
            }
        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);
}