kcenon::thread::configuration_manager Class Reference

Configuration manager for unified system configuration. More...

#include <configuration_manager.h>

Collaboration diagram for kcenon::thread::configuration_manager:

Public Types
using	change_callback = std::function<void(const std::string&, const config_value&)>
	Configuration change callback.
using	validator_func = std::function<validation_result(const std::string&, const config_value&)>
	Configuration validator.

Public Member Functions
	configuration_manager (std::shared_ptr< event_bus > bus=nullptr)
	Constructor.
bool	load_from_file (const std::filesystem::path &config_file)
	Load configuration from file.
bool	save_to_file (const std::filesystem::path &config_file) const
	Save configuration to file.
bool	set (const std::string &path, const config_value &value)
	Set a configuration value.
template<typename T >
T	get (const std::string &path, const T &default_value=T{}) const
	Get a configuration value.
template<typename T >
std::optional< T >	get_optional (const std::string &path) const
	Get a configuration value as optional.
bool	has (const std::string &path) const
	Check if configuration exists.
bool	remove (const std::string &path)
	Remove a configuration value.
std::size_t	on_change (const std::string &path, change_callback callback)
	Register a change callback.
void	remove_callback (const std::string &path, std::size_t id)
	Unregister a change callback.
void	add_validator (const std::string &path, validator_func validator)
	Register a configuration validator.
validation_result	validate_all () const
	Validate all configuration.
void	apply_system_config (const std::string &system_name, const std::unordered_map< std::string, config_value > &config)
	Apply configuration for a specific system.
std::unordered_map< std::string, config_value >	get_system_config (const std::string &system_name) const
	Get configuration for a specific system.
void	clear ()
	Clear all configuration.

Static Public Member Functions
static configuration_manager &	instance ()
	Get singleton instance.

Private Member Functions
void	parse_config_line (const std::string &line)
	Parse a configuration line.
std::string	value_to_string (const config_value &value) const
	Convert value to string.
bool	values_equal (const config_value &a, const config_value &b) const
	Check if two values are equal.
void	notify_change (const std::string &path, const config_value &value)
	Notify change callbacks.

Private Attributes
std::mutex	mutex_
std::mutex	callbacks_mutex_
std::unordered_map< std::string, config_value >	config_
std::unordered_map< std::string, validator_func >	validators_
std::unordered_map< std::string, std::unordered_map< std::size_t, change_callback > >	callbacks_
std::shared_ptr< event_bus >	event_bus_
std::size_t	next_callback_id_ {1}

Detailed Description

Configuration manager for unified system configuration.

Definition at line 61 of file configuration_manager.h.

Member Typedef Documentation

change_callback

using kcenon::thread::configuration_manager::change_callback = std::function<void(const std::string&, const config_value&)>

Configuration change callback.

Definition at line 66 of file configuration_manager.h.

validator_func

using kcenon::thread::configuration_manager::validator_func = std::function<validation_result(const std::string&, const config_value&)>

Configuration validator.

Definition at line 71 of file configuration_manager.h.

Constructor & Destructor Documentation

configuration_manager()

kcenon::thread::configuration_manager::configuration_manager ( std::shared_ptr< event_bus > bus = nullptr )

inlineexplicit

Constructor.

Parameters

event_bus

Optional event bus for change notifications

Definition at line 77 of file configuration_manager.h.

        : event_bus_(bus) {
        if (!event_bus_) {
            event_bus_ = std::make_shared<event_bus>();
        }
    }

References event_bus_.

Member Function Documentation

add_validator()

void kcenon::thread::configuration_manager::add_validator ( const std::string & path, validator_func validator )

inline

Register a configuration validator.

Parameters

path	Configuration path
validator	Validator function

Definition at line 268 of file configuration_manager.h.

                                                                        {
        std::lock_guard<std::mutex> lock(mutex_);
        validators_[path] = std::move(validator);
    }

References mutex_, and validators_.

apply_system_config()

void kcenon::thread::configuration_manager::apply_system_config ( const std::string & system_name, const std::unordered_map< std::string, config_value > & config )

inline

Apply configuration for a specific system.

Parameters

system_name	System name (e.g., "thread_system")
config	Configuration map

Definition at line 304 of file configuration_manager.h.

                                                                                     {
        for (const auto& [key, value] : config) {
            set(system_name + "." + key, value);
        }
    }

References set().

Here is the call graph for this function:

clear()

void kcenon::thread::configuration_manager::clear ( )

inline

Clear all configuration.

Definition at line 334 of file configuration_manager.h.

                 {
        std::lock_guard<std::mutex> lock(mutex_);
        config_.clear();
    }

References config_, and mutex_.

get()

template<typename T >

T kcenon::thread::configuration_manager::get ( const std::string & path, const T & default_value = T{} ) const

inline

Get a configuration value.

Template Parameters

T	Value type

Parameters

path	Configuration path
default_value	Default value if not found

Returns

Configuration value

Definition at line 182 of file configuration_manager.h.

                                                           {}) const {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = config_.find(path);
        if (it != config_.end()) {
            try {
                return std::get<T>(it->second);
            } catch (const std::bad_variant_access&) {
                // Type mismatch
            }
        }
        return default_value;
    }

get_optional()

template<typename T >

std::optional< T > kcenon::thread::configuration_manager::get_optional ( const std::string & path ) const

inline

Get a configuration value as optional.

Template Parameters

T	Value type

Parameters

path	Configuration path

Returns

Optional configuration value

Definition at line 202 of file configuration_manager.h.

                                                             {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = config_.find(path);
        if (it != config_.end()) {
            try {
                return std::get<T>(it->second);
            } catch (const std::bad_variant_access&) {
                // Type mismatch
            }
        }
        return std::nullopt;
    }

References config_, and mutex_.

get_system_config()

std::unordered_map< std::string, config_value > kcenon::thread::configuration_manager::get_system_config ( const std::string & system_name ) const

inline

Get configuration for a specific system.

Parameters

system_name

System name

Returns

Configuration map

Definition at line 316 of file configuration_manager.h.

                                            {
        std::unordered_map<std::string, config_value> result;
        std::string prefix = system_name + ".";
 
        std::lock_guard<std::mutex> lock(mutex_);
        for (const auto& [key, value] : config_) {
            if (key.starts_with(prefix)) {
                result[key.substr(prefix.length())] = value;
            }
        }
 
        return result;
    }

References config_, and mutex_.

has()

bool kcenon::thread::configuration_manager::has ( const std::string & path ) const

inline

Check if configuration exists.

Parameters

path	Configuration path

Returns

True if exists

Definition at line 220 of file configuration_manager.h.

                                          {
        std::lock_guard<std::mutex> lock(mutex_);
        return config_.find(path) != config_.end();
    }

References config_, and mutex_.

instance()

static configuration_manager & kcenon::thread::configuration_manager::instance ( )

inlinestatic

Get singleton instance.

Returns

Configuration manager instance

Definition at line 343 of file configuration_manager.h.

                                             {
        static configuration_manager instance;
        return instance;
    }

References instance().

Referenced by instance().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_file()

bool kcenon::thread::configuration_manager::load_from_file ( const std::filesystem::path & config_file )

inline

Load configuration from file.

Parameters

config_file

Path to configuration file

Returns

True if successful

Definition at line 89 of file configuration_manager.h.

                                                              {
        if (!std::filesystem::exists(config_file)) {
            return false;
        }
 
        try {
            std::ifstream file(config_file);
            if (!file.is_open()) {
                return false;
            }
 
            // Simple key=value parser for demonstration
            // In production, use JSON/YAML parser
            std::string line;
            while (std::getline(file, line)) {
                parse_config_line(line);
            }
 
            return true;
        } catch (...) {
            return false;
        }
    }

References parse_config_line().

Here is the call graph for this function:

notify_change()

void kcenon::thread::configuration_manager::notify_change ( const std::string & path, const config_value & value )

inlineprivate

Notify change callbacks.

Definition at line 428 of file configuration_manager.h.

                                                                         {
        std::lock_guard<std::mutex> lock(callbacks_mutex_);
 
        // Notify specific path callbacks
        if (auto it = callbacks_.find(path); it != callbacks_.end()) {
            for (const auto& [id, callback] : it->second) {
                callback(path, value);
            }
        }
 
        // Notify global callbacks
        if (auto it = callbacks_.find(""); it != callbacks_.end()) {
            for (const auto& [id, callback] : it->second) {
                callback(path, value);
            }
        }
    }

References kcenon::thread::callback, callbacks_, and callbacks_mutex_.

Referenced by set().

Here is the caller graph for this function:

on_change()

std::size_t kcenon::thread::configuration_manager::on_change ( const std::string & path, change_callback callback )

inline

Register a change callback.

Parameters

path	Configuration path (empty for all changes)
callback	Callback function

Returns

Callback ID for unregistration

Definition at line 241 of file configuration_manager.h.

                                                                         {
        std::lock_guard<std::mutex> lock(callbacks_mutex_);
        auto id = next_callback_id_++;
        callbacks_[path][id] = std::move(callback);
        return id;
    }

References kcenon::thread::callback, callbacks_, callbacks_mutex_, and next_callback_id_.

parse_config_line()

void kcenon::thread::configuration_manager::parse_config_line ( const std::string & line )

inlineprivate

Parse a configuration line.

Definition at line 352 of file configuration_manager.h.

                                                  {
        if (line.empty() || line[0] == '#' || line[0] == ';') {
            return; // Skip comments and empty lines
        }
 
        auto pos = line.find('=');
        if (pos != std::string::npos) {
            std::string key = line.substr(0, pos);
            std::string value_str = line.substr(pos + 1);
 
            // Trim whitespace
            key.erase(0, key.find_first_not_of(" \t"));
            key.erase(key.find_last_not_of(" \t") + 1);
            value_str.erase(0, value_str.find_first_not_of(" \t"));
            value_str.erase(value_str.find_last_not_of(" \t") + 1);
 
            // Parse value type
            config_value value;
            if (value_str == "true" || value_str == "false") {
                value = (value_str == "true");
            } else if (std::all_of(value_str.begin(), value_str.end(), ::isdigit)) {
                value = std::stoi(value_str);
            } else {
                try {
                    value = std::stod(value_str);
                } catch (...) {
                    value = value_str; // Default to string
                }
            }
 
            set(key, value);
        }
    }

References set().

Referenced by load_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

remove()

bool kcenon::thread::configuration_manager::remove ( const std::string & path )

inline

Remove a configuration value.

Parameters

path	Configuration path

Returns

True if removed

Definition at line 230 of file configuration_manager.h.

                                       {
        std::lock_guard<std::mutex> lock(mutex_);
        return config_.erase(path) > 0;
    }

References config_, and mutex_.

remove_callback()

void kcenon::thread::configuration_manager::remove_callback ( const std::string & path, std::size_t id )

inline

Unregister a change callback.

Parameters

path	Configuration path
id	Callback ID

Definition at line 253 of file configuration_manager.h.

                                                              {
        std::lock_guard<std::mutex> lock(callbacks_mutex_);
        if (auto it = callbacks_.find(path); it != callbacks_.end()) {
            it->second.erase(id);
            if (it->second.empty()) {
                callbacks_.erase(it);
            }
        }
    }

References callbacks_, and callbacks_mutex_.

save_to_file()

bool kcenon::thread::configuration_manager::save_to_file ( const std::filesystem::path & config_file ) const

inline

Save configuration to file.

Parameters

config_file

Path to configuration file

Returns

True if successful

Definition at line 118 of file configuration_manager.h.

                                                                  {
        try {
            std::ofstream file(config_file);
            if (!file.is_open()) {
                return false;
            }
 
            std::lock_guard<std::mutex> lock(mutex_);
            for (const auto& [key, value] : config_) {
                file << key << "=" << value_to_string(value) << "\n";
            }
 
            return true;
        } catch (...) {
            return false;
        }
    }

References config_, mutex_, and value_to_string().

Here is the call graph for this function:

set()

bool kcenon::thread::configuration_manager::set ( const std::string & path, const config_value & value )

inline

Set a configuration value.

Parameters

path	Configuration path (e.g., "thread_system.pool_size")
value	Configuration value

Returns

True if successful

Definition at line 142 of file configuration_manager.h.

                                                               {
        // Validate if validator exists
        if (auto it = validators_.find(path); it != validators_.end()) {
            auto result = it->second(path, value);
            if (!result.is_valid) {
                return false;
            }
        }
 
        config_value old_value;
        bool had_value = false;
 
        {
            std::lock_guard<std::mutex> lock(mutex_);
            if (auto it = config_.find(path); it != config_.end()) {
                old_value = it->second;
                had_value = true;
            }
            config_[path] = value;
        }
 
        // Notify callbacks
        notify_change(path, value);
 
        // Publish event if value changed
        if (event_bus_ && (!had_value || !values_equal(old_value, value))) {
            event_bus_->publish(config_changed_event(path, old_value, value));
        }
 
        return true;
    }

References config_, event_bus_, mutex_, notify_change(), validators_, and values_equal().

Referenced by apply_system_config(), and parse_config_line().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_all()

validation_result kcenon::thread::configuration_manager::validate_all ( ) const

inline

Validate all configuration.

Returns

Validation result

Definition at line 277 of file configuration_manager.h.

                                           {
        validation_result result;
        std::lock_guard<std::mutex> lock(mutex_);
 
        for (const auto& [path, value] : config_) {
            if (auto it = validators_.find(path); it != validators_.end()) {
                auto path_result = it->second(path, value);
                if (!path_result.is_valid) {
                    result.is_valid = false;
                    for (const auto& error : path_result.errors) {
                        result.add_error(path + ": " + error);
                    }
                }
                for (const auto& warning : path_result.warnings) {
                    result.add_warning(path + ": " + warning);
                }
            }
        }
 
        return result;
    }

References config_, mutex_, validators_, and kcenon::thread::warning.

value_to_string()

std::string kcenon::thread::configuration_manager::value_to_string ( const config_value & value ) const

inlineprivate

Convert value to string.

Definition at line 389 of file configuration_manager.h.

                                                               {
        return std::visit([](const auto& v) -> std::string {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, bool>) {
                return v ? "true" : "false";
            } else if constexpr (std::is_same_v<T, std::string>) {
                return v;
            } else if constexpr (std::is_arithmetic_v<T>) {
                return std::to_string(v);
            } else {
                return ""; // Complex types need custom serialization
            }
        }, value);
    }

Referenced by save_to_file().

Here is the caller graph for this function:

values_equal()

bool kcenon::thread::configuration_manager::values_equal ( const config_value & a, const config_value & b ) const

inlineprivate

Check if two values are equal.

Uses std::visit to compare per-type because std::unordered_map<std::string, std::any> does not support operator==.

Definition at line 410 of file configuration_manager.h.

                                                                          {
        if (a.index() != b.index()) {
            return false;
        }
        return std::visit([&b](const auto& val_a) -> bool {
            using T = std::decay_t<decltype(val_a)>;
            const auto& val_b = std::get<T>(b);
            if constexpr (std::is_same_v<T, std::unordered_map<std::string, std::any>>) {
                return false; // std::any has no operator==
            } else {
                return val_a == val_b;
            }
        }, a);
    }

Referenced by set().

Here is the caller graph for this function:

Member Data Documentation

callbacks_

std::unordered_map<std::string, std::unordered_map<std::size_t, change_callback> > kcenon::thread::configuration_manager::callbacks_

private

Definition at line 450 of file configuration_manager.h.

Referenced by notify_change(), on_change(), and remove_callback().

callbacks_mutex_

std::mutex kcenon::thread::configuration_manager::callbacks_mutex_

mutableprivate

Definition at line 447 of file configuration_manager.h.

Referenced by notify_change(), on_change(), and remove_callback().

config_

std::unordered_map<std::string, config_value> kcenon::thread::configuration_manager::config_

private

Definition at line 448 of file configuration_manager.h.

Referenced by clear(), get_optional(), get_system_config(), has(), remove(), save_to_file(), set(), and validate_all().

event_bus_

std::shared_ptr<event_bus> kcenon::thread::configuration_manager::event_bus_

private

Definition at line 451 of file configuration_manager.h.

Referenced by configuration_manager(), and set().

mutex_

std::mutex kcenon::thread::configuration_manager::mutex_

mutableprivate

Definition at line 446 of file configuration_manager.h.

Referenced by add_validator(), clear(), get_optional(), get_system_config(), has(), remove(), save_to_file(), set(), and validate_all().

next_callback_id_

std::size_t kcenon::thread::configuration_manager::next_callback_id_ {1}

private

Definition at line 452 of file configuration_manager.h.

{1};

Referenced by on_change().

validators_

std::unordered_map<std::string, validator_func> kcenon::thread::configuration_manager::validators_

private

Definition at line 449 of file configuration_manager.h.

Referenced by add_validator(), set(), and validate_all().

---

The documentation for this class was generated from the following file:

• include/kcenon/thread/core/configuration_manager.h