ConfigComponent.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CONSOLIX_CONFIG_COMPONENT_HPP_INCLUDED
#define _CONSOLIX_CONFIG_COMPONENT_HPP_INCLUDED

 
#if CONSOLIX_USE_JSON == 1
 
#include <atomic>
#include <fstream>
#include <mutex>
#include <string>
 
#include <nlohmann/json.hpp>
 
namespace consolix {

    template <typename ConfigType>
    class ConfigComponent : public IAppComponent {
    public:
        explicit ConfigComponent(
            const std::string& default_file = "config.json",
            const std::string& cli_flag = "--config")
            : m_default_file(default_file), m_cli_flag(cli_flag) {
        }

        void reload() {
            load_config();
        }
 
    protected:

        bool initialize() override {
#           if CONSOLIX_USE_CXXOPTS == 1
            if (has_service<CliOptions>() && !has_service<CliArguments>()) {
                return false;
            }
#           endif
            load_config();
            m_is_init = true;
            return true;
        }

        bool is_initialized() const override {
            return m_is_init;
        }

        void process() override {}
 
    private:
        std::string m_default_file; 
        std::string m_cli_flag;     
        ConfigType  m_config_data;  
        std::atomic<bool> m_is_init{false}; 
        std::mutex  m_mutex;

        void load_config() {
            std::lock_guard<std::mutex> lock(m_mutex);
            std::string config_path = resolve_file_path();
#           if defined(_WIN32) || defined(_WIN64)
            std::ifstream file(utf8_to_ansi(config_path));
#           else
            std::ifstream file(config_path);
#           endif
 
            if (!file) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Failed to open config file: ", config_path);
#               endif
                CONSOLIX_STREAM() <<
                    consolix::color(consolix::TextColor::Red) <<
                    "Failed to open config file: " << config_path;
                throw std::runtime_error("Failed to open config file: " + config_path);
            }
 
            try {
                // Read file content
                std::string json_content((std::istreambuf_iterator<char>(file)),
                                         std::istreambuf_iterator<char>());
 
                // Remove comments from the JSON string
                json_content = strip_json_comments(json_content);
 
                // Parse JSON
                nlohmann::json json_data = nlohmann::json::parse(json_content);
 
                m_config_data = json_data.get<ConfigType>();
                store_config_service();
            } catch (const std::exception& e) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Failed to parse config file: ", e.what());
#               endif
                CONSOLIX_STREAM() <<
                    consolix::color(consolix::TextColor::Red) <<
                    "Failed to parse config file: " << e.what();
                throw;
            }
        }

        std::string resolve_file_path() {
            std::string config_path = m_default_file;
            
#           if CONSOLIX_USE_CXXOPTS == 1
            if (has_service<CliArguments>()) {
                auto& args = get_service<CliArguments>();
                if (args.count(m_cli_flag)) {
                    config_path = args[m_cli_flag].template as<std::string>();
                }
            }
#           endif
 
            return resolve_exec_path(config_path);
        }

        void store_config_service() {
            if (has_service<ConfigType>()) {
                get_service<ConfigType>() = m_config_data;
                return;
            }
 
            register_service<ConfigType>([this]() {
                return std::make_shared<ConfigType>(m_config_data);
            });
        }
    };
 
} // namespace consolix
 
#endif // #if CONSOLIX_USE_JSON == 1
 
#endif // _CONSOLIX_CONFIG_COMPONENT_HPP_INCLUDED