Monitors configuration files for changes and supports hot-reload. More...

#include <config_watcher.h>

Collaboration diagram for kcenon::common::config::config_watcher:

Public Types
using	change_callback
	Callback type for configuration changes.

using	error_callback = std::function<void(const std::string& error_message)>
	Callback type for reload errors.

Public Member Functions
	config_watcher (const std::string &config_path, size_t max_history=10)
	Construct a config_watcher for the specified file.

	~config_watcher ()
	Destructor. Automatically stops watching if running.

	config_watcher (const config_watcher &)=delete

config_watcher &	operator= (const config_watcher &)=delete

	config_watcher (config_watcher &&)=delete

config_watcher &	operator= (config_watcher &&)=delete

VoidResult	start ()
	Start watching the configuration file for changes.

void	stop ()
	Stop watching the configuration file.

bool	is_running () const
	Check if the watcher is currently running.

void	on_change (change_callback callback)
	Register a callback for configuration changes.

void	on_error (error_callback callback)
	Register a callback for reload errors.

VoidResult	reload ()
	Manually trigger a configuration reload.

const unified_config &	current () const
	Get the current configuration.

uint64_t	version () const
	Get the current configuration version.

std::vector< config_snapshot >	history (size_t count=0) const
	Get configuration history snapshots.

VoidResult	rollback (uint64_t target_version)
	Rollback to a previous configuration version.

const std::string &	config_path () const
	Get the path to the configuration file being watched.

std::vector< config_change_event >	recent_events (size_t count=10) const
	Get recent change events.

Private Member Functions
VoidResult	init_platform_watcher ()
	Initialize platform-specific file watching.

void	signal_watcher_shutdown ()
	Signal the watch thread to wake up and exit.

void	cleanup_platform_watcher ()
	Cleanup platform-specific resources (call after thread join).

void	watch_loop ()
	Main watch loop - dispatches to platform-specific implementation.

VoidResult	do_reload ()
	Perform the actual configuration reload.

void	add_to_history (const unified_config &config)
	Add a configuration to history.

void	add_event (const config_change_event &event)
	Add a change event to the event log.

void	notify_change (const unified_config &old_cfg, const unified_config &new_cfg)
	Notify all registered change callbacks.

void	notify_error (const std::string &message)
	Notify all registered error callbacks.

Static Private Member Functions
static std::vector< std::string >	get_changed_fields (const unified_config &old_cfg, const unified_config &new_cfg)
	Compare two configurations and return changed field paths.

Private Attributes
std::string	config_path_

unified_config	current_config_

std::shared_mutex	config_mutex_

std::atomic< uint64_t >	version_

size_t	max_history_

std::mutex	history_mutex_

std::deque< config_snapshot >	history_

std::mutex	events_mutex_

std::deque< config_change_event >	events_

std::mutex	callbacks_mutex_

std::vector< change_callback >	change_callbacks_

std::vector< error_callback >	error_callbacks_

std::atomic< bool >	running_

std::thread	watch_thread_

Detailed Description

Monitors configuration files for changes and supports hot-reload.

The config_watcher provides automatic configuration reloading when the configuration file is modified. It supports:

Platform-native file watching
Callback notifications for configuration changes
Version tracking and history
Automatic rollback on validation failures

Usage Example:

config_watcher watcher("config.yaml");
 
watcher.on_change([](const unified_config& old_cfg,
                     const unified_config& new_cfg) {
    std::cout << "Configuration updated\n";
    // Apply changes...
});
 
watcher.start();
 
// ... application runs ...
 
watcher.stop();

Examples: config_watcher_example.cpp.

Definition at line 143 of file config_watcher.h.

Member Typedef Documentation

◆ change_callback

using kcenon::common::config::config_watcher::change_callback

Initial value:

std::function<void(const unified_config& old_config,

const unified_config& new_config)>

Callback type for configuration changes.

Definition at line 146 of file config_watcher.h.

◆ error_callback

using kcenon::common::config::config_watcher::error_callback = std::function<void(const std::string& error_message)>

Callback type for reload errors.

Definition at line 150 of file config_watcher.h.

Constructor & Destructor Documentation

◆ config_watcher() [1/3]

kcenon::common::config::config_watcher::config_watcher	(	const std::string &	config_path,
		size_t	max_history = 10 )

inlineexplicit

Construct a config_watcher for the specified file.

Parameters

config_path	Path to the YAML configuration file
max_history	Maximum number of configuration snapshots to keep (default: 10)

Definition at line 157 of file config_watcher.h.

        : config_path_(config_path)
        , version_(0)
        , max_history_(max_history)
        , running_(false)
#if defined(__linux__)
        , inotify_fd_(-1)
        , watch_fd_(-1)
        , shutdown_fd_(-1)
#elif defined(__APPLE__) || defined(__FreeBSD__)
        , kqueue_fd_(-1)
        , file_fd_(-1)
#elif defined(_WIN32)
        , dir_handle_(INVALID_HANDLE_VALUE)
#endif
    {
        // Load initial configuration
        auto result = config_loader::load(config_path_);
        if (result.is_ok()) {
            current_config_ = result.value();
            add_to_history(current_config_);
        } else {
            // Start with defaults if file doesn't exist or can't be loaded
            current_config_ = config_loader::defaults();
            add_to_history(current_config_);
        }
    }

References add_to_history(), config_path_, current_config_, kcenon::common::config::config_loader::defaults(), and kcenon::common::config::config_loader::load().

Here is the call graph for this function:

◆ ~config_watcher()

kcenon::common::config::config_watcher::~config_watcher ( )

inline

Destructor. Automatically stops watching if running.

Definition at line 188 of file config_watcher.h.

                      {
        stop();
    }

References stop().

Here is the call graph for this function:

◆ config_watcher() [2/3]

kcenon::common::config::config_watcher::config_watcher ( const config_watcher & )

delete

◆ config_watcher() [3/3]

kcenon::common::config::config_watcher::config_watcher ( config_watcher && )

delete

Member Function Documentation

◆ add_event()

void kcenon::common::config::config_watcher::add_event ( const config_change_event & event )

inlineprivate

Add a change event to the event log.

Definition at line 974 of file config_watcher.h.

                                                     {
        std::lock_guard<std::mutex> lock(events_mutex_);
        events_.push_back(event);
 
        // Keep only recent events
        while (events_.size() > 100) {
            events_.pop_front();
        }
    }

◆ add_to_history()

void kcenon::common::config::config_watcher::add_to_history ( const unified_config & config )

inlineprivate

Add a configuration to history.

Definition at line 955 of file config_watcher.h.

                                                      {
        std::lock_guard<std::mutex> lock(history_mutex_);
 
        config_snapshot snapshot;
        snapshot.version = version_.load();
        snapshot.timestamp = std::chrono::system_clock::now();
        snapshot.config = config;
 
        history_.push_back(snapshot);
 
        // Trim history if needed
        while (history_.size() > max_history_) {
            history_.pop_front();
        }
    }

References kcenon::common::config::config_snapshot::config, kcenon::common::config::config_snapshot::timestamp, and kcenon::common::config::config_snapshot::version.

Referenced by config_watcher().

Here is the caller graph for this function:

◆ cleanup_platform_watcher()

void kcenon::common::config::config_watcher::cleanup_platform_watcher ( )

inlineprivate

Cleanup platform-specific resources (call after thread join).

Definition at line 424 of file config_watcher.h.

                                    {
#if defined(__linux__)
        cleanup_inotify();
#elif defined(__APPLE__) || defined(__FreeBSD__)
        cleanup_kqueue();
#elif defined(_WIN32)
        cleanup_win32_watcher();
#endif
    }

Referenced by stop().

Here is the caller graph for this function:

◆ config_path()

const std::string & kcenon::common::config::config_watcher::config_path ( ) const

inline

Get the path to the configuration file being watched.

Returns: Configuration file path

Definition at line 357 of file config_watcher.h.

                                         {
        return config_path_;
    }

References config_path_.

◆ current()

const unified_config & kcenon::common::config::config_watcher::current ( ) const

inline

Get the current configuration.

Returns: Reference to the current unified_config

Definition at line 289 of file config_watcher.h.

                                          {
        std::shared_lock<std::shared_mutex> lock(config_mutex_);
        return current_config_;
    }

References config_mutex_, and current_config_.

◆ do_reload()

VoidResult kcenon::common::config::config_watcher::do_reload ( )

inlineprivate

Perform the actual configuration reload.

Definition at line 815 of file config_watcher.h.

                           {
        auto result = config_loader::load(config_path_);
 
        config_change_event event;
        event.timestamp = std::chrono::system_clock::now();
        event.version = version_.load() + 1;
 
        if (result.is_err()) {
            event.success = false;
            event.error_message = result.error().message;
            add_event(event);
            notify_error(result.error().message);
            return make_error<std::monostate>(result.error());
        }
 
        unified_config new_config = result.value();
 
        // Validate the new configuration
        auto validation_result = config_loader::validate(new_config);
        if (validation_result.is_err()) {
            event.success = false;
            event.error_message = validation_result.error().message;
            add_event(event);
            notify_error("Validation failed: " + validation_result.error().message);
            return make_error<std::monostate>(
                watcher_error_codes::validation_failed,
                "Configuration validation failed: " + validation_result.error().message,
                "config_watcher"
            );
        }
 
        // Get changed fields
        std::unique_lock<std::shared_mutex> lock(config_mutex_);
        event.changed_fields = get_changed_fields(current_config_, new_config);
 
        // Check if any non-hot-reloadable fields changed
        std::vector<std::string> non_reloadable_changes;
        for (const auto& field : event.changed_fields) {
            if (!is_hot_reloadable(field)) {
                non_reloadable_changes.push_back(field);
            }
        }
 
        // Update configuration
        unified_config old_config = current_config_;
        current_config_ = new_config;
        version_.fetch_add(1);
        event.version = version_.load();
        event.success = true;
 
        // Add to history
        add_to_history(new_config);
 
        lock.unlock();
 
        // Record event
        add_event(event);
 
        // Notify callbacks
        notify_change(old_config, new_config);
 
        return VoidResult::ok({});
    }

References kcenon::common::config::is_hot_reloadable(), kcenon::common::config::config_loader::load(), kcenon::common::make_error(), kcenon::common::Result< T >::ok(), kcenon::common::config::config_loader::validate(), and kcenon::common::config::watcher_error_codes::validation_failed.

Referenced by reload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_changed_fields()

static std::vector< std::string > kcenon::common::config::config_watcher::get_changed_fields	(	const unified_config &	old_cfg,
		const unified_config &	new_cfg )

inlinestaticprivate

Compare two configurations and return changed field paths.

Definition at line 882 of file config_watcher.h.

      {
        std::vector<std::string> changes;
 
        // Thread config
        if (old_cfg.thread.pool_size != new_cfg.thread.pool_size) {
            changes.push_back("thread.pool_size");
        }
        if (old_cfg.thread.queue_type != new_cfg.thread.queue_type) {
            changes.push_back("thread.queue_type");
        }
        if (old_cfg.thread.max_queue_size != new_cfg.thread.max_queue_size) {
            changes.push_back("thread.max_queue_size");
        }
 
        // Logger config
        if (old_cfg.logger.level != new_cfg.logger.level) {
            changes.push_back("logger.level");
        }
        if (old_cfg.logger.async != new_cfg.logger.async) {
            changes.push_back("logger.async");
        }
        if (old_cfg.logger.buffer_size != new_cfg.logger.buffer_size) {
            changes.push_back("logger.buffer_size");
        }
        if (old_cfg.logger.file_path != new_cfg.logger.file_path) {
            changes.push_back("logger.file_path");
        }
        if (old_cfg.logger.writers != new_cfg.logger.writers) {
            changes.push_back("logger.writers");
        }
 
        // Monitoring config
        if (old_cfg.monitoring.enabled != new_cfg.monitoring.enabled) {
            changes.push_back("monitoring.enabled");
        }
        if (old_cfg.monitoring.metrics_interval != new_cfg.monitoring.metrics_interval) {
            changes.push_back("monitoring.metrics_interval");
        }
        if (old_cfg.monitoring.tracing.enabled != new_cfg.monitoring.tracing.enabled) {
            changes.push_back("monitoring.tracing.enabled");
        }
        if (old_cfg.monitoring.tracing.sampling_rate != new_cfg.monitoring.tracing.sampling_rate) {
            changes.push_back("monitoring.tracing.sampling_rate");
        }
 
        // Database config
        if (old_cfg.database.backend != new_cfg.database.backend) {
            changes.push_back("database.backend");
        }
        if (old_cfg.database.connection_string != new_cfg.database.connection_string) {
            changes.push_back("database.connection_string");
        }
 
        // Network config
        if (old_cfg.network.tls.enabled != new_cfg.network.tls.enabled) {
            changes.push_back("network.tls.enabled");
        }
        if (old_cfg.network.compression != new_cfg.network.compression) {
            changes.push_back("network.compression");
        }
        if (old_cfg.network.buffer_size != new_cfg.network.buffer_size) {
            changes.push_back("network.buffer_size");
        }
 
        return changes;
    }

◆ history()

std::vector< config_snapshot > kcenon::common::config::config_watcher::history ( size_t count = 0 ) const

inline

Get configuration history snapshots.

Parameters

count Maximum number of snapshots to return (default: all)

Returns: Vector of configuration snapshots, newest first

Definition at line 307 of file config_watcher.h.

                                                               {
        std::lock_guard<std::mutex> lock(history_mutex_);
 
        if (count == 0 || count > history_.size()) {
            return {history_.rbegin(), history_.rend()};
        }
 
        std::vector<config_snapshot> result;
        result.reserve(count);
        auto it = history_.rbegin();
        for (size_t i = 0; i < count && it != history_.rend(); ++i, ++it) {
            result.push_back(*it);
        }
        return result;
    }

References history_, and history_mutex_.

◆ init_platform_watcher()

VoidResult kcenon::common::config::config_watcher::init_platform_watcher ( )

inlineprivate

Initialize platform-specific file watching.

Definition at line 386 of file config_watcher.h.

                                       {
#if defined(__linux__)
        return init_inotify();
#elif defined(__APPLE__) || defined(__FreeBSD__)
        return init_kqueue();
#elif defined(_WIN32)
        return init_win32_watcher();
#else
        return make_error<std::monostate>(
            watcher_error_codes::platform_not_supported,
            "File watching not supported on this platform",
            "config_watcher"
        );
#endif
    }

References kcenon::common::make_error(), and kcenon::common::config::watcher_error_codes::platform_not_supported.

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_running()

bool kcenon::common::config::config_watcher::is_running ( ) const

inline

Check if the watcher is currently running.

Returns: true if watching, false otherwise

Examples: config_watcher_example.cpp.

Definition at line 248 of file config_watcher.h.

                            {
        return running_.load();
    }

References running_.

Referenced by main().

Here is the caller graph for this function:

◆ notify_change()

void kcenon::common::config::config_watcher::notify_change	(	const unified_config &	old_cfg,
		const unified_config &	new_cfg )

inlineprivate

Notify all registered change callbacks.

Definition at line 987 of file config_watcher.h.

                                                                                     {
        std::lock_guard<std::mutex> lock(callbacks_mutex_);
        for (const auto& callback : change_callbacks_) {
            try {
                callback(old_cfg, new_cfg);
            } catch (...) {
                // Ignore callback exceptions
            }
        }
    }

Referenced by rollback().

Here is the caller graph for this function:

◆ notify_error()

void kcenon::common::config::config_watcher::notify_error ( const std::string & message )

inlineprivate

Notify all registered error callbacks.

Definition at line 1001 of file config_watcher.h.

                                                {
        std::lock_guard<std::mutex> lock(callbacks_mutex_);
        for (const auto& callback : error_callbacks_) {
            try {
                callback(message);
            } catch (...) {
                // Ignore callback exceptions
            }
        }
    }

◆ on_change()

void kcenon::common::config::config_watcher::on_change ( change_callback callback )

inline

Register a callback for configuration changes.

The callback will be invoked whenever the configuration is successfully reloaded. Multiple callbacks can be registered.

Parameters

callback Function to call on configuration change

Examples: config_watcher_example.cpp.

Definition at line 260 of file config_watcher.h.

                                             {
        std::lock_guard<std::mutex> lock(callbacks_mutex_);
        change_callbacks_.push_back(std::move(callback));
    }

References callbacks_mutex_, and change_callbacks_.

Referenced by main().

Here is the caller graph for this function:

◆ on_error()

void kcenon::common::config::config_watcher::on_error ( error_callback callback )

inline

Register a callback for reload errors.

The callback will be invoked when a reload attempt fails.

Parameters

callback Function to call on reload error

Examples: config_watcher_example.cpp.

Definition at line 272 of file config_watcher.h.

                                           {
        std::lock_guard<std::mutex> lock(callbacks_mutex_);
        error_callbacks_.push_back(std::move(callback));
    }

References callbacks_mutex_, and error_callbacks_.

Referenced by main().

Here is the caller graph for this function:

◆ operator=() [1/2]

config_watcher & kcenon::common::config::config_watcher::operator= ( config_watcher && )

delete

◆ operator=() [2/2]

config_watcher & kcenon::common::config::config_watcher::operator= ( const config_watcher & )

delete

◆ recent_events()

std::vector< config_change_event > kcenon::common::config::config_watcher::recent_events ( size_t count = 10 ) const

inline

Get recent change events.

Parameters

count Maximum number of events to return

Returns: Vector of recent change events

Definition at line 366 of file config_watcher.h.

                                                                          {
        std::lock_guard<std::mutex> lock(events_mutex_);
 
        if (count == 0 || count > events_.size()) {
            return {events_.rbegin(), events_.rend()};
        }
 
        std::vector<config_change_event> result;
        result.reserve(count);
        auto it = events_.rbegin();
        for (size_t i = 0; i < count && it != events_.rend(); ++i, ++it) {
            result.push_back(*it);
        }
        return result;
    }

References events_, and events_mutex_.

◆ reload()

VoidResult kcenon::common::config::config_watcher::reload ( )

inline

Manually trigger a configuration reload.

Returns: VoidResult indicating success or failure

Examples: config_watcher_example.cpp.

Definition at line 281 of file config_watcher.h.

                        {
        return do_reload();
    }

References do_reload().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rollback()

VoidResult kcenon::common::config::config_watcher::rollback ( uint64_t target_version )

inline

Rollback to a previous configuration version.

Parameters

target_version Version number to rollback to

Returns: VoidResult indicating success or failure

Definition at line 328 of file config_watcher.h.

                                                 {
        std::lock_guard<std::mutex> lock(history_mutex_);
 
        for (const auto& snapshot : history_) {
            if (snapshot.version == target_version) {
                std::unique_lock<std::shared_mutex> config_lock(config_mutex_);
                unified_config old_config = current_config_;
                current_config_ = snapshot.config;
                version_.fetch_add(1);
 
                // Notify callbacks
                config_lock.unlock();
                notify_change(old_config, current_config_);
 
                return VoidResult::ok({});
            }
        }
 
        return make_error<std::monostate>(
            watcher_error_codes::rollback_failed,
            "Target version not found in history: " + std::to_string(target_version),
            "config_watcher"
        );
    }

References config_mutex_, current_config_, history_, history_mutex_, kcenon::common::make_error(), notify_change(), kcenon::common::Result< T >::ok(), kcenon::common::config::watcher_error_codes::rollback_failed, and version_.

Here is the call graph for this function:

◆ signal_watcher_shutdown()

void kcenon::common::config::config_watcher::signal_watcher_shutdown ( )

inlineprivate

Signal the watch thread to wake up and exit.

Definition at line 405 of file config_watcher.h.

                                   {
#if defined(__linux__)
        signal_eventfd();
#elif defined(__APPLE__) || defined(__FreeBSD__)
        // Closing kqueue wakes up kevent() with an error
        int kq = kqueue_fd_.exchange(-1);
        if (kq >= 0) {
            close(kq);
        }
#elif defined(_WIN32)
        if (dir_handle_ != INVALID_HANDLE_VALUE) {
            CancelIo(dir_handle_);
        }
#endif
    }

Referenced by stop().

Here is the caller graph for this function:

◆ start()

VoidResult kcenon::common::config::config_watcher::start ( )

inline

Start watching the configuration file for changes.

Returns: VoidResult indicating success or failure

Examples: config_watcher_example.cpp.

Definition at line 202 of file config_watcher.h.

                       {
        if (running_.load()) {
            return make_error<std::monostate>(
                watcher_error_codes::already_running,
                "Config watcher is already running",
                "config_watcher"
            );
        }
 
        auto init_result = init_platform_watcher();
        if (init_result.is_err()) {
            return init_result;
        }
 
        running_.store(true);
        watch_thread_ = std::thread([this]() { watch_loop(); });
 
        return VoidResult::ok({});
    }

References kcenon::common::config::watcher_error_codes::already_running, init_platform_watcher(), kcenon::common::make_error(), kcenon::common::Result< T >::ok(), running_, watch_loop(), and watch_thread_.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop()

void kcenon::common::config::config_watcher::stop ( )

inline

Stop watching the configuration file.

Examples: config_watcher_example.cpp.

Definition at line 225 of file config_watcher.h.

                {
        if (!running_.load()) {
            return;
        }
 
        running_.store(false);
 
        // Signal the watch thread to wake up
        signal_watcher_shutdown();
 
        // Wait for the thread to exit before closing file descriptors
        if (watch_thread_.joinable()) {
            watch_thread_.join();
        }
 
        // Thread has exited; safe to close platform resources
        cleanup_platform_watcher();
    }

References cleanup_platform_watcher(), running_, signal_watcher_shutdown(), and watch_thread_.

Referenced by main(), and ~config_watcher().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ version()

uint64_t kcenon::common::config::config_watcher::version ( ) const

inline

Get the current configuration version.

Returns: Current version number

Definition at line 298 of file config_watcher.h.

                             {
        return version_.load();
    }

References version_.

◆ watch_loop()

void kcenon::common::config::config_watcher::watch_loop ( )

inlineprivate

Main watch loop - dispatches to platform-specific implementation.

Definition at line 802 of file config_watcher.h.

                      {
#if defined(__linux__)
        watch_loop_linux();
#elif defined(__APPLE__) || defined(__FreeBSD__)
        watch_loop_kqueue();
#elif defined(_WIN32)
        watch_loop_win32();
#endif
    }

Referenced by start().

Here is the caller graph for this function:

Member Data Documentation

◆ callbacks_mutex_

std::mutex kcenon::common::config::config_watcher::callbacks_mutex_

private

Definition at line 1030 of file config_watcher.h.

Referenced by on_change(), and on_error().

◆ change_callbacks_

std::vector<change_callback> kcenon::common::config::config_watcher::change_callbacks_

private

Definition at line 1031 of file config_watcher.h.

Referenced by on_change().

◆ config_mutex_

std::shared_mutex kcenon::common::config::config_watcher::config_mutex_

mutableprivate

Definition at line 1015 of file config_watcher.h.

Referenced by current(), and rollback().

◆ config_path_

std::string kcenon::common::config::config_watcher::config_path_

private

Definition at line 1013 of file config_watcher.h.

Referenced by config_path(), and config_watcher().

◆ current_config_

unified_config kcenon::common::config::config_watcher::current_config_

private

Definition at line 1014 of file config_watcher.h.

Referenced by config_watcher(), current(), and rollback().

◆ error_callbacks_

std::vector<error_callback> kcenon::common::config::config_watcher::error_callbacks_

private

Definition at line 1032 of file config_watcher.h.

Referenced by on_error().

◆ events_

std::deque<config_change_event> kcenon::common::config::config_watcher::events_

private

Definition at line 1027 of file config_watcher.h.

Referenced by recent_events().

◆ events_mutex_

std::mutex kcenon::common::config::config_watcher::events_mutex_

mutableprivate

Definition at line 1026 of file config_watcher.h.

Referenced by recent_events().

◆ history_

std::deque<config_snapshot> kcenon::common::config::config_watcher::history_

private

Definition at line 1023 of file config_watcher.h.

Referenced by history(), and rollback().

◆ history_mutex_

std::mutex kcenon::common::config::config_watcher::history_mutex_

mutableprivate

Definition at line 1022 of file config_watcher.h.

Referenced by history(), and rollback().

◆ max_history_

size_t kcenon::common::config::config_watcher::max_history_

private

Definition at line 1021 of file config_watcher.h.

◆ running_

std::atomic<bool> kcenon::common::config::config_watcher::running_

private

Definition at line 1035 of file config_watcher.h.

Referenced by is_running(), start(), and stop().

◆ version_

std::atomic<uint64_t> kcenon::common::config::config_watcher::version_

private

Definition at line 1018 of file config_watcher.h.

Referenced by rollback(), and version().

◆ watch_thread_

std::thread kcenon::common::config::config_watcher::watch_thread_

private

Definition at line 1036 of file config_watcher.h.

Referenced by start(), and stop().

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

include/kcenon/common/config/config_watcher.h

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ change_callback

◆ error_callback

Constructor & Destructor Documentation

◆ config_watcher() [1/3]

◆ ~config_watcher()

◆ config_watcher() [2/3]

◆ config_watcher() [3/3]

Member Function Documentation

◆ add_event()

◆ add_to_history()

◆ cleanup_platform_watcher()

◆ config_path()

◆ current()

◆ do_reload()

◆ get_changed_fields()

◆ history()

◆ init_platform_watcher()

◆ is_running()

◆ notify_change()

◆ notify_error()

◆ on_change()

◆ on_error()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ recent_events()

◆ reload()

◆ rollback()

◆ signal_watcher_shutdown()

◆ start()

◆ stop()

◆ version()

◆ watch_loop()

Member Data Documentation

◆ callbacks_mutex_

◆ change_callbacks_

◆ config_mutex_

◆ config_path_

◆ current_config_

◆ error_callbacks_

◆ events_

◆ events_mutex_

◆ history_

◆ history_mutex_

◆ max_history_

◆ running_

◆ version_

◆ watch_thread_