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
{
    namespace core
    {
        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]]
            Value get(const std::string& key);
 
            template<meta::standard_type Value>
            [[nodiscard]]
            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:
            bool m_loaded;
 
            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
        {
            if (m_loaded)
            {
                m_config["config"][key] = value;
            }
            else
            {
                GALAXY_LOG(GALAXY_ERROR, "Attempted to set value of an unloaded config file.");
            }
        }
 
        template<meta::standard_type Value>
        inline void Config::set(const std::string& key, const Value& value, const std::string& section, const std::string& delim)
        {
            if (m_loaded)
            {
                const auto sections = strutils::split(section, delim);
                if (sections.empty())
                {
                    // Single section.
                    m_config["config"][section][key] = value;
                }
                else
                {
                    // Multiple sections.
                    nlohmann::json* leaf = &m_config["config"];
                    for (const auto& sec : sections)
                    {
                        if (!leaf->contains(sec))
                        {
                            (*leaf)[sec] = nlohmann::json::object();
                        }
 
                        leaf = &leaf->at(sec);
                    }
 
                    (*leaf)[key] = value;
                }
            }
            else
            {
                GALAXY_LOG(GALAXY_ERROR, "Attempted to set value of an unloaded config file.");
            }
        }
 
        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 Value Config::get(const std::string& key)
        {
            if (m_loaded)
            {
                const auto& section = m_config["config"];
 
                if (section.contains(key))
                {
                    return section[key].get<Value>();
                }
            }
            else
            {
                GALAXY_LOG(GALAXY_FATAL, "Attempted to get value of an unloaded config file.");
            }
 
            GALAXY_LOG(GALAXY_FATAL, "Failed to retrieve '{0}' from config.", key);
 
            return Value {};
        }
 
        template<meta::standard_type Value>
        inline Value Config::get(const std::string& key, const std::string& section, const std::string& delim)
        {
            if (m_loaded)
            {
                const auto sections = strutils::split(section, delim);
                if (sections.empty())
                {
                    // Single section.
                    const auto& root = m_config["config"];
                    if (root.contains(section))
                    {
                        const auto& obj = root[section];
                        if (obj.contains(key))
                        {
                            return obj[key].get<Value>();
                        }
                    }
 
                    GALAXY_LOG(GALAXY_FATAL, "Failed to retrieve '{0}' from config.", key);
                    return Value {};
                }
                else
                {
                    // Multiple sections.
                    nlohmann::json* leaf = &m_config["config"];
                    for (const auto& sec : sections)
                    {
                        if (leaf->contains(sec))
                        {
                            leaf = &leaf->at(sec);
                        }
                    }
 
                    if (leaf->contains(key))
                    {
                        return (*leaf)[key].get<Value>();
                    }
 
                    GALAXY_LOG(GALAXY_FATAL, "Failed to retrieve '{0}' from config.", key);
                    return Value {};
                }
            }
            else
            {
                GALAXY_LOG(GALAXY_FATAL, "Attempted to get value of an unloaded config file.");
            }
 
            GALAXY_LOG(GALAXY_FATAL, "Failed to retrieve '{0}' from config.", key);
            return Value {};
        }
    } // namespace core
} // namespace galaxy
 
#endif