kcenon::network::integration::ThreadPoolBridge Class Reference

Bridge for thread pool integration implementing INetworkBridge. More...

#include <thread_pool_bridge.h>

Inheritance diagram for kcenon::network::integration::ThreadPoolBridge:

Collaboration diagram for kcenon::network::integration::ThreadPoolBridge:

Public Types
enum class	BackendType { ThreadSystem , CommonSystem , Custom }
	Type of thread pool backend. More...

Public Member Functions
	~ThreadPoolBridge () override
	Destructor.
VoidResult	initialize (const BridgeConfig &config) override
	Initialize the bridge with configuration.
VoidResult	shutdown () override
	Shutdown the bridge.
bool	is_initialized () const override
	Check if the bridge is initialized.
BridgeMetrics	get_metrics () const override
	Get current metrics.
std::shared_ptr< thread_pool_interface >	get_thread_pool () const
	Get the underlying thread pool.
BackendType	get_backend_type () const
	Get the backend type.
Public Member Functions inherited from kcenon::network::integration::INetworkBridge
virtual	~INetworkBridge ()=default

Static Public Member Functions
static Result< std::shared_ptr< ThreadPoolBridge > >	create (std::shared_ptr< thread_pool_interface > pool, BackendType backend_type=BackendType::Custom)
	Construct bridge with custom thread pool.
static Result< std::shared_ptr< ThreadPoolBridge > >	from_thread_system (const std::string &pool_name="network_pool")
	Create bridge from thread_system.

Private Member Functions
	ThreadPoolBridge (std::shared_ptr< thread_pool_interface > pool, BackendType backend_type)

Private Attributes
std::shared_ptr< thread_pool_interface >	pool_
BackendType	backend_type_
std::atomic< bool >	initialized_ {false}
std::mutex	metrics_mutex_
BridgeMetrics	cached_metrics_

Detailed Description

Bridge for thread pool integration implementing INetworkBridge.

This class consolidates thread_system and common_system thread pool integrations into a single, unified bridge. It provides factory methods for creating bridges from different backend types.

Backend Types:

• ThreadSystem: Uses thread_system's thread pool directly
• CommonSystem: Adapts common_system's IExecutor
• Custom: Uses user-provided thread_pool_interface

Lifecycle:

1. Create using factory method (from_thread_system, from_common_system) or direct constructor
2. Call initialize() with configuration
3. Use get_thread_pool() to access the underlying pool
4. Call shutdown() before destruction

Thread Safety:

• initialize() and shutdown() are not thread-safe (single-threaded usage)
• get_metrics() is thread-safe for concurrent queries
• get_thread_pool() is thread-safe after initialization

Definition at line 81 of file thread_pool_bridge.h.

Member Enumeration Documentation

BackendType

enum class kcenon::network::integration::ThreadPoolBridge::BackendType

strong

Type of thread pool backend.

Enumerator
ThreadSystem	Uses thread_system's thread pool.
CommonSystem	Uses common_system's IExecutor.
Custom	Uses custom thread_pool_interface.

Definition at line 87 of file thread_pool_bridge.h.

                           {
        ThreadSystem,  
        CommonSystem,  
        Custom         
    };

Constructor & Destructor Documentation

~ThreadPoolBridge()

kcenon::network::integration::ThreadPoolBridge::~ThreadPoolBridge ( )

override

Destructor.

Automatically calls shutdown() if initialized

Definition at line 31 of file thread_pool_bridge.cpp.

                                    {
    if (initialized_.load()) {
        shutdown();
    }
}

References initialized_, and shutdown().

Here is the call graph for this function:

ThreadPoolBridge()

kcenon::network::integration::ThreadPoolBridge::ThreadPoolBridge ( std::shared_ptr< thread_pool_interface > pool, BackendType backend_type )

private

Definition at line 25 of file thread_pool_bridge.cpp.

    : pool_(std::move(pool)), backend_type_(backend_type) {
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

create()

Result< std::shared_ptr< ThreadPoolBridge > > kcenon::network::integration::ThreadPoolBridge::create ( std::shared_ptr< thread_pool_interface > pool, BackendType backend_type = BackendType::Custom )

staticnodiscard

Construct bridge with custom thread pool.

Parameters

pool	Thread pool implementation
backend_type	Type of backend (default: Custom)

Exceptions

std::invalid_argument

if pool is nullptr

Example:

auto pool = std::make_shared<basic_thread_pool>(8);
auto bridge = std::make_shared<ThreadPoolBridge>(pool);

Definition at line 13 of file thread_pool_bridge.cpp.

                                                                         {
    if (!pool) {
        return error<std::shared_ptr<ThreadPoolBridge>>(
            error_codes::common_errors::invalid_argument,
            "ThreadPoolBridge requires non-null thread pool",
            "ThreadPoolBridge::create");
    }
    return ok(std::shared_ptr<ThreadPoolBridge>(
        new ThreadPoolBridge(std::move(pool), backend_type)));
}

References kcenon::network::integration::error, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), and ThreadPoolBridge().

Referenced by from_thread_system(), and kcenon::network::integration::NetworkSystemBridge::with_custom().

Here is the call graph for this function:

Here is the caller graph for this function:

from_thread_system()

Result< std::shared_ptr< ThreadPoolBridge > > kcenon::network::integration::ThreadPoolBridge::from_thread_system ( const std::string & pool_name = "network_pool" )

staticnodiscard

Create bridge from thread_system.

Parameters

pool_name

Thread pool name (default: "network_pool")

Returns

Shared pointer to ThreadPoolBridge

Creates a bridge using thread_system's thread pool via thread_integration_manager.

Example:

auto bridge = ThreadPoolBridge::from_thread_system("network_pool");
BridgeConfig config;
config.integration_name = "thread_system";
bridge->initialize(config);

Definition at line 132 of file thread_pool_bridge.cpp.

                                {
    (void)pool_name;
    auto pool = thread_integration_manager::instance().get_thread_pool();
    if (!pool) {
        return error<std::shared_ptr<ThreadPoolBridge>>(
            error_codes::common_errors::not_initialized,
            "Failed to get thread pool from thread_integration_manager",
            "ThreadPoolBridge::from_thread_system");
    }
    return create(pool, BackendType::ThreadSystem);
}

References create(), kcenon::network::integration::error, kcenon::network::integration::thread_integration_manager::get_thread_pool(), kcenon::network::integration::thread_integration_manager::instance(), kcenon::network::error_codes::common_errors::not_initialized, and ThreadSystem.

Referenced by kcenon::network::integration::NetworkSystemBridge::create_default(), and kcenon::network::integration::NetworkSystemBridge::with_thread_system().

Here is the call graph for this function:

Here is the caller graph for this function:

get_backend_type()

ThreadPoolBridge::BackendType kcenon::network::integration::ThreadPoolBridge::get_backend_type

(

)

const

Get the backend type.

Returns

Type of backend this bridge uses

Definition at line 128 of file thread_pool_bridge.cpp.

                                                                     {
    return backend_type_;
}

References backend_type_.

get_metrics()

BridgeMetrics kcenon::network::integration::ThreadPoolBridge::get_metrics ( ) const

overridevirtual

Get current metrics.

Returns

Bridge metrics including thread pool statistics

Custom Metrics:

• "worker_threads": Number of worker threads
• "pending_tasks": Number of queued tasks
• "backend_type": Backend type (0=ThreadSystem, 1=CommonSystem, 2=Custom)

Thread Safety: Safe to call concurrently

Implements kcenon::network::integration::INetworkBridge.

Definition at line 100 of file thread_pool_bridge.cpp.

                                                  {
    std::lock_guard<std::mutex> lock(metrics_mutex_);
 
    if (!initialized_.load() || !pool_) {
        BridgeMetrics metrics;
        metrics.is_healthy = false;
        metrics.last_activity = cached_metrics_.last_activity;
        return metrics;
    }
 
    // Update metrics with current thread pool state
    BridgeMetrics metrics = cached_metrics_;
    metrics.is_healthy = pool_->is_running();
    metrics.last_activity = std::chrono::steady_clock::now();
    metrics.custom_metrics["worker_threads"] = static_cast<double>(pool_->worker_count());
    metrics.custom_metrics["pending_tasks"] = static_cast<double>(pool_->pending_tasks());
    metrics.custom_metrics["backend_type"] = static_cast<double>(backend_type_);
 
    // Update cached metrics for next call
    cached_metrics_ = metrics;
 
    return metrics;
}

References backend_type_, cached_metrics_, kcenon::network::integration::BridgeMetrics::custom_metrics, initialized_, kcenon::network::integration::BridgeMetrics::is_healthy, kcenon::network::integration::BridgeMetrics::last_activity, metrics_mutex_, and pool_.

get_thread_pool()

std::shared_ptr< thread_pool_interface > kcenon::network::integration::ThreadPoolBridge::get_thread_pool

(

)

const

Get the underlying thread pool.

Returns

Shared pointer to thread pool, or nullptr if not initialized

Thread Safety: Safe to call after initialization

Example:

if (auto pool = bridge->get_thread_pool()) {
    pool->submit([]{ // task implementation here });
}

Definition at line 124 of file thread_pool_bridge.cpp.

                                                                             {
    return pool_;
}

References pool_.

initialize()

VoidResult kcenon::network::integration::ThreadPoolBridge::initialize ( const BridgeConfig & config )

overridevirtual

Initialize the bridge with configuration.

Parameters

config

Configuration parameters

Returns

ok() on success, error_info on failure

Configuration Properties:

• "enabled": "true" or "false" (default: "true")
• "worker_count": Number of worker threads (informational)
• "pool_name": Thread pool identifier (informational)

Error Conditions:

• Already initialized
• Underlying thread pool not running
• Invalid configuration

Example:

BridgeConfig config;
config.integration_name = "thread_system";
config.properties["pool_name"] = "network_pool";
config.properties["worker_count"] = "8";
 
auto result = bridge->initialize(config);
if (result.is_err()) {
    std::cerr << "Init failed: " << result.error().message << std::endl;
}

Implements kcenon::network::integration::INetworkBridge.

Definition at line 37 of file thread_pool_bridge.cpp.

                                                                  {
    if (initialized_.load()) {
        return error_void(
            error_codes::common_errors::already_exists,
            "ThreadPoolBridge already initialized",
            "ThreadPoolBridge::initialize");
    }
 
    if (!pool_) {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "Thread pool is null",
            "ThreadPoolBridge::initialize");
    }
 
    if (!pool_->is_running()) {
        return error_void(
            error_codes::common_errors::not_initialized,
            "Thread pool is not running",
            "ThreadPoolBridge::initialize");
    }
 
    // Check if bridge is enabled (default: true)
    auto enabled_it = config.properties.find("enabled");
    if (enabled_it != config.properties.end() && enabled_it->second == "false") {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "Bridge is disabled in configuration",
            "ThreadPoolBridge::initialize");
    }
 
    // Initialize metrics
    std::lock_guard<std::mutex> lock(metrics_mutex_);
    cached_metrics_.is_healthy = true;
    cached_metrics_.last_activity = std::chrono::steady_clock::now();
    cached_metrics_.custom_metrics["worker_threads"] = static_cast<double>(pool_->worker_count());
    cached_metrics_.custom_metrics["pending_tasks"] = static_cast<double>(pool_->pending_tasks());
    cached_metrics_.custom_metrics["backend_type"] = static_cast<double>(backend_type_);
 
    initialized_.store(true);
    return ok();
}

References kcenon::network::error_codes::common_errors::already_exists, backend_type_, cached_metrics_, config, kcenon::network::integration::BridgeMetrics::custom_metrics, kcenon::network::error_void(), initialized_, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::integration::BridgeMetrics::is_healthy, kcenon::network::integration::BridgeMetrics::last_activity, metrics_mutex_, kcenon::network::error_codes::common_errors::not_initialized, kcenon::network::ok(), and pool_.

Here is the call graph for this function:

is_initialized()

bool kcenon::network::integration::ThreadPoolBridge::is_initialized ( ) const

overridevirtual

Check if the bridge is initialized.

Returns

true if initialized and ready, false otherwise

Implements kcenon::network::integration::INetworkBridge.

Definition at line 96 of file thread_pool_bridge.cpp.

                                            {
    return initialized_.load() && pool_ && pool_->is_running();
}

References initialized_, and pool_.

shutdown()

VoidResult kcenon::network::integration::ThreadPoolBridge::shutdown ( )

overridevirtual

Shutdown the bridge.

Returns

ok() on success, error_info on failure

Shuts down the bridge but does not shut down the underlying thread pool. Thread pool lifecycle is managed externally.

This method is idempotent - multiple calls are safe.

Implements kcenon::network::integration::INetworkBridge.

Definition at line 80 of file thread_pool_bridge.cpp.

                                      {
    if (!initialized_.load()) {
        return ok(); // Idempotent: already shut down
    }
 
    // Update metrics to reflect shutdown state
    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
        cached_metrics_.is_healthy = false;
        cached_metrics_.last_activity = std::chrono::steady_clock::now();
    }
 
    initialized_.store(false);
    return ok();
}

References cached_metrics_, initialized_, kcenon::network::integration::BridgeMetrics::is_healthy, kcenon::network::integration::BridgeMetrics::last_activity, metrics_mutex_, and kcenon::network::ok().

Referenced by ~ThreadPoolBridge().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

backend_type_

BackendType kcenon::network::integration::ThreadPoolBridge::backend_type_

private

Definition at line 248 of file thread_pool_bridge.h.

Referenced by get_backend_type(), get_metrics(), and initialize().

cached_metrics_

BridgeMetrics kcenon::network::integration::ThreadPoolBridge::cached_metrics_

mutableprivate

Definition at line 251 of file thread_pool_bridge.h.

Referenced by get_metrics(), initialize(), and shutdown().

initialized_

std::atomic<bool> kcenon::network::integration::ThreadPoolBridge::initialized_ {false}

private

Definition at line 249 of file thread_pool_bridge.h.

{false};

Referenced by get_metrics(), initialize(), is_initialized(), shutdown(), and ~ThreadPoolBridge().

metrics_mutex_

std::mutex kcenon::network::integration::ThreadPoolBridge::metrics_mutex_

mutableprivate

Definition at line 250 of file thread_pool_bridge.h.

Referenced by get_metrics(), initialize(), and shutdown().

pool_

std::shared_ptr<thread_pool_interface> kcenon::network::integration::ThreadPoolBridge::pool_

private

Definition at line 247 of file thread_pool_bridge.h.

Referenced by get_metrics(), get_thread_pool(), initialize(), and is_initialized().

---

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

• src/internal/integration/thread_pool_bridge.h
• src/integration/thread_pool_bridge.cpp