kcenon::common::di::unified_bootstrapper Class Reference

Coordinates system initialization and shutdown. More...

#include <unified_bootstrapper.h>

Collaboration diagram for kcenon::common::di::unified_bootstrapper:

Classes
struct	module_entry
struct	shutdown_hook_entry

Public Member Functions
	unified_bootstrapper ()=delete
	~unified_bootstrapper ()=delete
	unified_bootstrapper (const unified_bootstrapper &)=delete
unified_bootstrapper &	operator= (const unified_bootstrapper &)=delete

Static Public Member Functions
static VoidResult	initialize (const bootstrapper_options &opts={})
	Initialize the unified system.
static VoidResult	shutdown (std::chrono::milliseconds timeout=std::chrono::seconds(30))
	Shutdown the unified system gracefully.
static service_container &	services ()
	Get the service container.
static bool	is_initialized ()
	Check if the system is initialized.
static bool	is_shutdown_requested ()
	Check if shutdown has been requested.
static VoidResult	register_shutdown_hook (const std::string &name, shutdown_hook hook)
	Register a shutdown hook.
static VoidResult	unregister_shutdown_hook (const std::string &name)
	Unregister a shutdown hook.
static void	request_shutdown (bool trigger_shutdown=false)
	Request graceful shutdown.
static bootstrapper_options	get_options ()
	Get the initialization options.
static VoidResult	register_module (const std::string &name, module_registration_fn fn)
	Register a module's service registration function.
template<typename M > requires concepts::ModuleRegistrar<M>
static VoidResult	register_module (M registrar)
	Register a class-based module registrar.
static VoidResult	unregister_module (const std::string &name)
	Unregister a module.
static std::vector< std::string >	registered_modules ()
	Get list of registered module names.
static bool	is_module_registered (const std::string &name)
	Check if a module is registered.

Static Private Member Functions
static VoidResult	register_core_services ()
	Register core services that are always required.
static VoidResult	register_optional_services (const bootstrapper_options &opts)
	Register optional services based on options.
static void	setup_default_shutdown_hooks ()
	Set up default shutdown hooks.
static void	setup_signal_handlers ()
	Set up signal handlers.
static void	signal_handler (int signal)
	Signal handler function.
static void	execute_shutdown_hooks (std::chrono::milliseconds timeout)
	Execute all shutdown hooks.

Static Private Attributes
static std::atomic< bool >	initialized_ {false}
static std::atomic< bool >	shutdown_requested_ {false}
static std::mutex	mutex_
static bootstrapper_options	options_
static std::vector< shutdown_hook_entry >	shutdown_hooks_
static std::vector< module_entry >	modules_

Detailed Description

Coordinates system initialization and shutdown.

The unified bootstrapper provides a single entry point for initializing all system components. It manages:

• Service registration order
• Dependency resolution
• Graceful shutdown with timeout
• Signal handler registration

Usage Example:

int main() {
    // Initialize with options
    auto result = unified_bootstrapper::initialize({
        .enable_logging = true,
        .enable_monitoring = true,
        .config_path = "config.yaml"
    });
 
    if (result.is_err()) {
        std::cerr << "Initialization failed: " << result.error().message << "\n";
        return 1;
    }
 
    // Get services
    auto& services = unified_bootstrapper::services();
    auto logger = services.resolve<interfaces::ILogger>();
 
    // Application logic...
 
    // Shutdown (or wait for signal)
    unified_bootstrapper::shutdown();
    return 0;
}

Definition at line 130 of file unified_bootstrapper.h.

Constructor & Destructor Documentation

unified_bootstrapper() [1/2]

kcenon::common::di::unified_bootstrapper::unified_bootstrapper ( )

delete

~unified_bootstrapper()

kcenon::common::di::unified_bootstrapper::~unified_bootstrapper ( )

delete

unified_bootstrapper() [2/2]

kcenon::common::di::unified_bootstrapper::unified_bootstrapper ( const unified_bootstrapper & )

delete

Member Function Documentation

execute_shutdown_hooks()

void kcenon::common::di::unified_bootstrapper::execute_shutdown_hooks ( std::chrono::milliseconds timeout )

inlinestaticprivate

Execute all shutdown hooks.

Definition at line 743 of file unified_bootstrapper.h.

                                   {
 
    auto start = std::chrono::steady_clock::now();
 
    // Execute hooks in reverse order (LIFO)
    for (auto it = shutdown_hooks_.rbegin(); it != shutdown_hooks_.rend(); ++it) {
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::steady_clock::now() - start);
        auto remaining = timeout - elapsed;
 
        if (remaining <= std::chrono::milliseconds::zero()) {
            // Timeout reached, skip remaining hooks
            break;
        }
 
        try {
            it->hook(remaining);
        } catch (...) {
            // Ignore exceptions during shutdown
        }
    }
}

References shutdown_hooks_.

Referenced by shutdown().

Here is the caller graph for this function:

get_options()

bootstrapper_options kcenon::common::di::unified_bootstrapper::get_options ( )

inlinestatic

Get the initialization options.

Returns

Current bootstrapper options (empty if not initialized)

Definition at line 533 of file unified_bootstrapper.h.

                                                              {
    std::lock_guard<std::mutex> lock(mutex_);
    return options_;
}

References mutex_, and options_.

initialize()

VoidResult kcenon::common::di::unified_bootstrapper::initialize ( const bootstrapper_options & opts = {} )

inlinestatic

Initialize the unified system.

Performs the following steps:

1. Registers core services (always required)
2. Registers optional services based on options
3. Sets up shutdown hooks
4. Registers signal handlers (if enabled)

This method is idempotent - calling it multiple times after successful initialization returns success without re-initializing.

Parameters

opts	Configuration options

Returns

VoidResult indicating success or initialization error

Possible errors:

• ALREADY_EXISTS: Already initialized with different options
• INTERNAL_ERROR: Service registration failed

Definition at line 380 of file unified_bootstrapper.h.

                                                                                   {
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Check if already initialized
    if (initialized_.load()) {
        return VoidResult::ok({});
    }
 
    // Store options
    options_ = opts;
 
    // Register core services
    auto core_result = register_core_services();
    if (core_result.is_err()) {
        return core_result;
    }
 
    // Register optional services
    auto optional_result = register_optional_services(opts);
    if (optional_result.is_err()) {
        // Cleanup on failure
        service_container::global().clear();
        // Reset module registration flags so they can be retried
        for (auto& module : modules_) {
            module.services_registered = false;
        }
        return optional_result;
    }
 
    // Set up default shutdown hooks
    setup_default_shutdown_hooks();
 
    // Set up signal handlers
    if (opts.register_signal_handlers) {
        setup_signal_handlers();
    }
 
    // Mark as initialized
    initialized_.store(true);
    shutdown_requested_.store(false);
 
    return VoidResult::ok({});
}

References kcenon::common::di::service_container::clear(), kcenon::common::di::service_container::global(), initialized_, modules_, mutex_, kcenon::common::Result< T >::ok(), options_, register_core_services(), register_optional_services(), kcenon::common::di::bootstrapper_options::register_signal_handlers, setup_default_shutdown_hooks(), setup_signal_handlers(), and shutdown_requested_.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

is_initialized()

bool kcenon::common::di::unified_bootstrapper::is_initialized ( )

inlinestatic

Check if the system is initialized.

Thread-safe check of initialization state.

Returns

true if initialized, false otherwise

Definition at line 466 of file unified_bootstrapper.h.

                                                 {
    return initialized_.load();
}

References initialized_.

is_module_registered()

bool kcenon::common::di::unified_bootstrapper::is_module_registered ( const std::string & name )

inlinestatic

Check if a module is registered.

Parameters

name	Module name to check

Returns

true if the module is registered

Definition at line 617 of file unified_bootstrapper.h.

                                                                            {
    std::lock_guard<std::mutex> lock(mutex_);
 
    return std::find_if(modules_.begin(), modules_.end(),
        [&name](const module_entry& entry) {
            return entry.name == name;
        }) != modules_.end();
}

References modules_, and mutex_.

is_shutdown_requested()

bool kcenon::common::di::unified_bootstrapper::is_shutdown_requested ( )

inlinestatic

Check if shutdown has been requested.

Thread-safe check of shutdown state. Useful for long-running operations to check if they should abort.

Returns

true if shutdown requested, false otherwise

Definition at line 470 of file unified_bootstrapper.h.

                                                        {
    return shutdown_requested_.load();
}

References shutdown_requested_.

operator=()

unified_bootstrapper & kcenon::common::di::unified_bootstrapper::operator= ( const unified_bootstrapper & )

delete

register_core_services()

VoidResult kcenon::common::di::unified_bootstrapper::register_core_services ( )

inlinestaticprivate

Register core services that are always required.

Definition at line 626 of file unified_bootstrapper.h.

                                                               {
    // Core services are minimal and always registered
    // The service_container itself is already available via services()
    // No additional core services are required at this time
    //
    // Future core services that might be registered here:
    // - Default error handlers
    // - Core diagnostics
    // - System-level configuration providers
    //
    // For now, just ensure the container is initialized
    // Subsystems register their own services via their adapter modules
 
    return VoidResult::ok({});
}

References kcenon::common::Result< T >::ok().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

register_module() [1/2]

VoidResult kcenon::common::di::unified_bootstrapper::register_module ( const std::string & name, module_registration_fn fn )

inlinestatic

Register a module's service registration function.

Modules can be registered before or after initialization:

• Before initialize(): stored and called during initialization
• After initialize(): called immediately with the service container

Parameters

name	Unique module name (e.g., "logger", "monitoring")
fn	Registration function that registers services with the container

Returns

VoidResult indicating success or error

Possible errors:

• ALREADY_EXISTS: Module with this name already registered

Definition at line 542 of file unified_bootstrapper.h.

                               {
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Check for duplicate
    for (const auto& entry : modules_) {
        if (entry.name == name) {
            return make_error<std::monostate>(
                error_codes::ALREADY_EXISTS,
                "Module already registered: " + name,
                "di::unified_bootstrapper"
            );
        }
    }
 
    // If already initialized, register services immediately
    if (initialized_.load()) {
        auto& container = service_container::global();
        auto result = fn(container);
        if (!result.is_ok()) {
            return result;
        }
        modules_.push_back({name, std::move(fn), true});
    } else {
        // Store for deferred registration during initialize()
        modules_.push_back({name, std::move(fn), false});
    }
 
    return VoidResult::ok({});
}

References kcenon::common::error_codes::ALREADY_EXISTS, kcenon::common::di::service_container::global(), initialized_, kcenon::common::make_error(), modules_, mutex_, and kcenon::common::Result< T >::ok().

Referenced by register_module().

Here is the call graph for this function:

Here is the caller graph for this function:

register_module() [2/2]

template<typename M >
requires concepts::ModuleRegistrar<M>

VoidResult kcenon::common::di::unified_bootstrapper::register_module ( M registrar )

static

Register a class-based module registrar.

Convenience overload that accepts any type satisfying the ModuleRegistrar concept.

Template Parameters

M	Type satisfying concepts::ModuleRegistrar

Parameters

registrar

Module registrar instance

Returns

VoidResult indicating success or error

See also

concepts::ModuleRegistrar

Definition at line 577 of file unified_bootstrapper.h.

                                                            {
    return register_module(
        std::string(M::module_name()),
        [r = std::move(registrar)](IServiceContainer& container) mutable {
            return r.register_services(container);
        }
    );
}

References register_module().

Here is the call graph for this function:

register_optional_services()

VoidResult kcenon::common::di::unified_bootstrapper::register_optional_services ( const bootstrapper_options & opts )

inlinestaticprivate

Register optional services based on options.

Definition at line 642 of file unified_bootstrapper.h.

                                      {
 
    // Optional services are registered based on configuration
    // Each subsystem provides registration functions via adapters
    // The registration is conditional based on:
    // 1. bootstrapper_options flags (enable_logging, etc.)
    // 2. Feature detection macros (KCENON_WITH_*_SYSTEM)
    // 3. Dynamically registered modules via register_module()
 
    auto& container = service_container::global();
 
    // --- Compile-time subsystem integration (legacy) ---
 
    // Logging services
    if (opts.enable_logging) {
#if KCENON_WITH_LOGGER_SYSTEM
        // When logger_system is available and registered via register_module(),
        // it will be handled below. The #ifdef path is kept for backward
        // compatibility until all subsystems migrate to register_module().
#endif
    }
 
    // Monitoring services
    if (opts.enable_monitoring) {
#if KCENON_WITH_MONITORING_SYSTEM
        // Same as above - handled by register_module() when available.
#endif
    }
 
    // Database services
    if (opts.enable_database) {
#if KCENON_WITH_DATABASE_SYSTEM
        // Same as above - handled by register_module() when available.
#endif
    }
 
    // Network services
    if (opts.enable_network) {
#if KCENON_WITH_NETWORK_SYSTEM
        // Same as above - handled by register_module() when available.
#endif
    }
 
    // --- Dynamic module registration ---
    // Call registration functions for all modules registered before initialize()
    for (auto& module : modules_) {
        if (!module.services_registered) {
            auto result = module.registration_fn(container);
            if (!result.is_ok()) {
                return make_error<std::monostate>(
                    result.error().code,
                    "Module '" + module.name + "' registration failed: "
                        + result.error().message,
                    "di::unified_bootstrapper"
                );
            }
            module.services_registered = true;
        }
    }
 
    return VoidResult::ok({});
}

References kcenon::common::di::bootstrapper_options::enable_database, kcenon::common::di::bootstrapper_options::enable_logging, kcenon::common::di::bootstrapper_options::enable_monitoring, kcenon::common::di::bootstrapper_options::enable_network, kcenon::common::di::service_container::global(), kcenon::common::make_error(), modules_, and kcenon::common::Result< T >::ok().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

register_shutdown_hook()

VoidResult kcenon::common::di::unified_bootstrapper::register_shutdown_hook ( const std::string & name, shutdown_hook hook )

inlinestatic

Register a shutdown hook.

Hooks are called in reverse order of registration during shutdown. Use for cleanup operations that must complete before the system shuts down.

Parameters

name	Unique name for the hook (for logging)
hook	Callback function to execute during shutdown

Returns

VoidResult indicating success or error

Possible errors:

• ALREADY_EXISTS: Hook with this name already registered
• NOT_INITIALIZED: System not initialized

Definition at line 474 of file unified_bootstrapper.h.

                        {
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!initialized_.load()) {
        return make_error<std::monostate>(
            error_codes::NOT_INITIALIZED,
            "System is not initialized",
            "di::unified_bootstrapper"
        );
    }
 
    // Check for duplicate
    for (const auto& entry : shutdown_hooks_) {
        if (entry.name == name) {
            return make_error<std::monostate>(
                error_codes::ALREADY_EXISTS,
                "Shutdown hook already registered: " + name,
                "di::unified_bootstrapper"
            );
        }
    }
 
    shutdown_hooks_.push_back({name, std::move(hook)});
    return VoidResult::ok({});
}

References kcenon::common::error_codes::ALREADY_EXISTS, initialized_, kcenon::common::make_error(), mutex_, kcenon::common::error_codes::NOT_INITIALIZED, kcenon::common::Result< T >::ok(), and shutdown_hooks_.

Here is the call graph for this function:

registered_modules()

std::vector< std::string > kcenon::common::di::unified_bootstrapper::registered_modules ( )

inlinestatic

Get list of registered module names.

Returns

Vector of module names

Definition at line 606 of file unified_bootstrapper.h.

                                                                     {
    std::lock_guard<std::mutex> lock(mutex_);
 
    std::vector<std::string> names;
    names.reserve(modules_.size());
    for (const auto& entry : modules_) {
        names.push_back(entry.name);
    }
    return names;
}

References modules_, and mutex_.

request_shutdown()

void kcenon::common::di::unified_bootstrapper::request_shutdown ( bool trigger_shutdown = false )

inlinestatic

Request graceful shutdown.

Sets the shutdown flag and optionally triggers shutdown. Can be called from signal handlers.

Parameters

trigger_shutdown

If true, also calls shutdown()

Definition at line 525 of file unified_bootstrapper.h.

                                                                        {
    shutdown_requested_.store(true);
 
    if (trigger_shutdown) {
        shutdown(options_.shutdown_timeout);
    }
}

References options_, shutdown(), shutdown_requested_, and kcenon::common::di::bootstrapper_options::shutdown_timeout.

Here is the call graph for this function:

services()

service_container & kcenon::common::di::unified_bootstrapper::services ( )

inlinestatic

Get the service container.

Returns

Reference to the global service container

Exceptions

std::runtime_error

if not initialized

Definition at line 456 of file unified_bootstrapper.h.

                                                         {
    if (!initialized_.load()) {
        throw std::runtime_error(
            "unified_bootstrapper: System is not initialized. "
            "Call initialize() first."
        );
    }
    return service_container::global();
}

References kcenon::common::di::service_container::global(), and initialized_.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_default_shutdown_hooks()

void kcenon::common::di::unified_bootstrapper::setup_default_shutdown_hooks ( )

inlinestaticprivate

Set up default shutdown hooks.

Definition at line 706 of file unified_bootstrapper.h.

                                                               {
    // Register default shutdown hooks for core cleanup
 
    // Service container cleanup hook (runs last, lowest priority)
    shutdown_hooks_.push_back({
        "service_container_cleanup",
        [](std::chrono::milliseconds) {
            // Container cleanup is handled by shutdown() itself
        }
    });
}

References shutdown_hooks_.

Referenced by initialize().

Here is the caller graph for this function:

setup_signal_handlers()

void kcenon::common::di::unified_bootstrapper::setup_signal_handlers ( )

inlinestaticprivate

Set up signal handlers.

Definition at line 718 of file unified_bootstrapper.h.

                                                        {
#ifndef _WIN32
    // POSIX signal handling
    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
 
    sigaction(SIGTERM, &sa, nullptr);
    sigaction(SIGINT, &sa, nullptr);
#else
    // Windows signal handling
    std::signal(SIGTERM, signal_handler);
    std::signal(SIGINT, signal_handler);
#endif
}

References signal_handler().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown()

VoidResult kcenon::common::di::unified_bootstrapper::shutdown ( std::chrono::milliseconds timeout = std::chrono::seconds(30) )

inlinestatic

Shutdown the unified system gracefully.

Performs the following steps:

1. Sets shutdown flag to prevent new operations
2. Calls shutdown hooks in reverse order
3. Clears all service registrations
4. Resets initialization state

Parameters

timeout

Maximum time to wait for graceful shutdown

Returns

VoidResult indicating success or shutdown error

Possible errors:

• TIMEOUT: Shutdown did not complete within timeout
• NOT_INITIALIZED: System was not initialized

Definition at line 424 of file unified_bootstrapper.h.

                                                                              {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!initialized_.load()) {
        return make_error<std::monostate>(
            error_codes::NOT_INITIALIZED,
            "System is not initialized",
            "di::unified_bootstrapper"
        );
    }
 
    // Mark shutdown as requested
    shutdown_requested_.store(true);
 
    // Execute shutdown hooks
    execute_shutdown_hooks(timeout);
 
    // Clear all services
    service_container::global().clear();
 
    // Clear shutdown hooks and modules
    shutdown_hooks_.clear();
    modules_.clear();
 
    // Reset state
    initialized_.store(false);
    shutdown_requested_.store(false);
    options_ = bootstrapper_options{};
 
    return VoidResult::ok({});
}

References kcenon::common::di::service_container::clear(), execute_shutdown_hooks(), kcenon::common::di::service_container::global(), initialized_, kcenon::common::make_error(), modules_, mutex_, kcenon::common::error_codes::NOT_INITIALIZED, kcenon::common::Result< T >::ok(), options_, shutdown_hooks_, and shutdown_requested_.

Referenced by main(), and request_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

signal_handler()

void kcenon::common::di::unified_bootstrapper::signal_handler ( int signal )

inlinestaticprivate

Signal handler function.

Definition at line 735 of file unified_bootstrapper.h.

                                                           {
    (void)signal;  // Unused parameter
 
    // Request shutdown but don't trigger it from signal handler
    // The main thread should check is_shutdown_requested() and call shutdown()
    shutdown_requested_.store(true);
}

References shutdown_requested_.

Referenced by setup_signal_handlers().

Here is the caller graph for this function:

unregister_module()

VoidResult kcenon::common::di::unified_bootstrapper::unregister_module ( const std::string & name )

inlinestatic

Unregister a module.

Removes a module registration. Does not unregister services that were already registered with the container.

Parameters

name	Name of the module to unregister

Returns

VoidResult indicating success or error

Possible errors:

• NOT_FOUND: Module with this name not found

Definition at line 586 of file unified_bootstrapper.h.

                                                                               {
    std::lock_guard<std::mutex> lock(mutex_);
 
    auto it = std::find_if(modules_.begin(), modules_.end(),
        [&name](const module_entry& entry) {
            return entry.name == name;
        });
 
    if (it == modules_.end()) {
        return make_error<std::monostate>(
            error_codes::NOT_FOUND,
            "Module not found: " + name,
            "di::unified_bootstrapper"
        );
    }
 
    modules_.erase(it);
    return VoidResult::ok({});
}

References kcenon::common::make_error(), modules_, mutex_, kcenon::common::error_codes::NOT_FOUND, and kcenon::common::Result< T >::ok().

Here is the call graph for this function:

unregister_shutdown_hook()

VoidResult kcenon::common::di::unified_bootstrapper::unregister_shutdown_hook ( const std::string & name )

inlinestatic

Unregister a shutdown hook.

Parameters

name	Name of the hook to unregister

Returns

VoidResult indicating success or error

Definition at line 503 of file unified_bootstrapper.h.

                           {
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    auto it = std::find_if(shutdown_hooks_.begin(), shutdown_hooks_.end(),
        [&name](const shutdown_hook_entry& entry) {
            return entry.name == name;
        });
 
    if (it == shutdown_hooks_.end()) {
        return make_error<std::monostate>(
            error_codes::NOT_FOUND,
            "Shutdown hook not found: " + name,
            "di::unified_bootstrapper"
        );
    }
 
    shutdown_hooks_.erase(it);
    return VoidResult::ok({});
}

References kcenon::common::make_error(), mutex_, kcenon::common::error_codes::NOT_FOUND, kcenon::common::Result< T >::ok(), and shutdown_hooks_.

Here is the call graph for this function:

Member Data Documentation

initialized_

std::atomic< bool > kcenon::common::di::unified_bootstrapper::initialized_ {false}

inlinestaticprivate

Definition at line 346 of file unified_bootstrapper.h.

Referenced by initialize(), is_initialized(), register_module(), register_shutdown_hook(), services(), and shutdown().

modules_

std::vector< unified_bootstrapper::module_entry > kcenon::common::di::unified_bootstrapper::modules_

inlinestaticprivate

Definition at line 364 of file unified_bootstrapper.h.

Referenced by initialize(), is_module_registered(), register_module(), register_optional_services(), registered_modules(), shutdown(), and unregister_module().

mutex_

std::mutex kcenon::common::di::unified_bootstrapper::mutex_

inlinestaticprivate

Definition at line 348 of file unified_bootstrapper.h.

Referenced by get_options(), initialize(), is_module_registered(), register_module(), register_shutdown_hook(), registered_modules(), shutdown(), unregister_module(), and unregister_shutdown_hook().

options_

bootstrapper_options kcenon::common::di::unified_bootstrapper::options_

inlinestaticprivate

Definition at line 349 of file unified_bootstrapper.h.

Referenced by get_options(), initialize(), request_shutdown(), and shutdown().

shutdown_hooks_

std::vector< unified_bootstrapper::shutdown_hook_entry > kcenon::common::di::unified_bootstrapper::shutdown_hooks_

inlinestaticprivate

Definition at line 356 of file unified_bootstrapper.h.

Referenced by execute_shutdown_hooks(), register_shutdown_hook(), setup_default_shutdown_hooks(), shutdown(), and unregister_shutdown_hook().

shutdown_requested_

std::atomic< bool > kcenon::common::di::unified_bootstrapper::shutdown_requested_ {false}

inlinestaticprivate

Definition at line 347 of file unified_bootstrapper.h.

Referenced by initialize(), is_shutdown_requested(), request_shutdown(), shutdown(), and signal_handler().

---

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

• include/kcenon/common/di/unified_bootstrapper.h