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 original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte-Config source in this
 * repository. They do not cover other StormByte modules or any third-party
 * material shipped with this repository. The bundled StormByte Base tree
 * under thirdparty/ remains under its own license.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * 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
 * version 3 along with StormByte-Config. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#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 <StormByte/platform.h>
#include <StormByte/size.hxx>
#include <StormByte/safe/string.hxx>
 
#include <istream>
#include <ostream>
#include <span>
#include <string>
#include <string_view>
 
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);
 
            Config(Config&& config) noexcept;
 
            Config& operator=(const Config& config);
 
            Config& operator=(Config&& config) noexcept;
 
            virtual ~Config() noexcept;
            inline Item::Base& operator[](const StormByte::Safe::String& path) {
                return m_root.operator[](path);
            }
 
            inline const Item::Base& operator[](const StormByte::Safe::String& path) const {
                return m_root.operator[](path);
            }
 
            inline Item::Base& operator[](std::string_view path) {
                return m_root.operator[](path);
            }
 
            inline const Item::Base& operator[](std::string_view path) const {
                return m_root.operator[](path);
            }
 
            Item::Base& operator[](const StormByte::Size& index) {
                return m_root[index];
            }
 
            const Item::Base& operator[](const StormByte::Size& 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 StormByte::Safe::String& str);
 
            void operator<<(const std::string& str);
 
            friend STORMBYTE_CONFIG_PUBLIC Config& operator>>(std::istream& istream, Config& file);
 
            friend STORMBYTE_CONFIG_PUBLIC Config& operator>>(const StormByte::Safe::String& str, 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& str, const Config& file);
 
            StormByte::Safe::String Text() const;
 
            STORMBYTE_FORCE_INLINE explicit operator std::string() const {
                return static_cast<std::string>(Text());
            }
 
            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 StormByte::Safe::String& path) const {
                return m_root.Exists(path);
            }
 
            inline bool Exists(std::string_view path) const {
                return m_root.Exists(path);
            }
 
            inline void Remove(const StormByte::Safe::String& path) {
                m_root.Remove(path);
            }
 
            inline void Remove(std::string_view path) {
                m_root.Remove(path);
            }
 
            inline void Remove(const StormByte::Size& index) {
                m_root.Remove(index);
            }
 
            StormByte::Size Size() const noexcept {
                return m_root.Size();
            }
 
            StormByte::Size Count() const noexcept {
                return m_root.Count();
            }
 
            constexpr std::span<const 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 StormByte::Config::OnExistingAction& on_existing);
 
            void OnParseFailure(OnFailureHook hook);
 
            void OnParseFailure(StormByte::Safe::Shared<FailureHook> hook);
 
            void AddHookBeforeRead(HookFunction hook);
 
            void AddHookBeforeRead(StormByte::Safe::Shared<ReadHook> hook);
 
            void AddHookAfterRead(HookFunction hook);
 
            void AddHookAfterRead(StormByte::Safe::Shared<ReadHook> 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 StormByte::Safe::String& str, 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);
}