Config.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_CORE_CONFIG_HPP_
#define GALAXY_CORE_CONFIG_HPP_
 
#include <nlohmann/json.hpp>
 
#include "galaxy/logging/Log.hpp"
#include "galaxy/meta/Concepts.hpp"
#include "galaxy/utils/StringUtils.hpp"
 
namespace galaxy
{
    class Config final
    {
    public:
        Config() noexcept;
 
        Config(std::string_view file) noexcept;
 
        ~Config() noexcept;
 
        void load(std::string_view file);
 
        void save();
 
        template<meta::standard_type Value>
        void set(const std::string& key, const Value& value) noexcept;
 
        template<meta::standard_type Value>
        void set(const std::string& key, const Value& value, const std::string& section, const std::string& delim = ".");
 
        template<meta::standard_type Value>
        void restore(const std::string& key, const Value& value) noexcept;
 
        template<meta::standard_type Value>
        void restore(const std::string& key, const Value& value, const std::string& section, const std::string& delim = ".");
 
        [[nodiscard]]
        bool has(const std::string& key) noexcept;
 
        [[nodiscard]]
        bool has(const std::string& key, const std::string& section, const std::string& delim = ".");
 
        template<meta::standard_type Value>
        [[nodiscard]]
        std::optional<Value> get(const std::string& key);
 
        template<meta::standard_type Value>
        [[nodiscard]]
        std::optional<Value> get(const std::string& key, const std::string& section, const std::string& delim = ".");
 
        [[nodiscard]]
        bool empty() const;
 
        void raw(const nlohmann::json& json) noexcept;
 
        [[nodiscard]]
        const nlohmann::json& raw() const noexcept;
 
    private:
        Config(const Config&) = delete;
 
        Config(Config&&) = delete;
 
        Config& operator=(const Config&) = delete;
 
        Config& operator=(Config&&) = delete;
 
    private:
        nlohmann::json m_config;
 
        std::string m_path;
    };
 
    template<meta::standard_type Value>
    inline void Config::set(const std::string& key, const Value& value) noexcept
    {
        m_config[key] = value;
    }
 
    template<meta::standard_type Value>
    inline void Config::set(const std::string& key, const Value& value, const std::string& section, const std::string& delim)
    {
        const auto sections = str::split(section, delim);
        if (sections.empty())
        {
            // Single section.
            m_config[section][key] = value;
        }
        else
        {
            // Multiple sections.
            nlohmann::json* leaf = &m_config;
            for (const auto& sec : sections)
            {
                if (!leaf->contains(sec))
                {
                    (*leaf)[sec] = nlohmann::json::object();
                }
 
                leaf = &leaf->at(sec);
            }
 
            (*leaf)[key] = value;
        }
    }
 
    template<meta::standard_type Value>
    inline void Config::restore(const std::string& key, const Value& value) noexcept
    {
        if (!has(key))
        {
            set(key, value);
        }
    }
 
    template<meta::standard_type Value>
    inline void Config::restore(const std::string& key, const Value& value, const std::string& section, const std::string& delim)
    {
        if (!has(key, section, delim))
        {
            set(key, value, section, delim);
        }
    }
 
    template<meta::standard_type Value>
    inline std::optional<Value> Config::get(const std::string& key)
    {
        const auto& section = m_config;
 
        if (section.contains(key))
        {
            return section[key].get<Value>();
        }
 
        return std::nullopt;
    }
 
    template<meta::standard_type Value>
    inline std::optional<Value> Config::get(const std::string& key, const std::string& section, const std::string& delim)
    {
        const auto sections = str::split(section, delim);
        if (sections.empty())
        {
            // Single section.
            const auto& root = m_config;
            if (root.contains(section))
            {
                const auto& obj = root[section];
                if (obj.contains(key))
                {
                    return obj[key].get<Value>();
                }
            }
 
            return std::nullopt;
        }
        else
        {
            // Multiple sections.
            nlohmann::json* leaf = &m_config;
            for (const auto& sec : sections)
            {
                if (leaf->contains(sec))
                {
                    leaf = &leaf->at(sec);
                }
            }
 
            if (leaf->contains(key))
            {
                return (*leaf)[key].get<Value>();
            }
 
            return std::nullopt;
        }
    }
} // namespace galaxy
 
#endif