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 (std::shared_ptr< thread_pool_interface > pool, BackendType backend_type=BackendType::Custom)
	Construct bridge with custom thread pool.

	~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 std::shared_ptr< ThreadPoolBridge >	from_thread_system (const std::string &pool_name="network_pool")
	Create bridge from thread_system.

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:

Create using factory method (from_thread_system, from_common_system) or direct constructor
Call initialize() with configuration
Use get_thread_pool() to access the underlying pool
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	(	std::shared_ptr< thread_pool_interface >	pool,
		BackendType	backend_type = BackendType::Custom )

explicit

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);

kcenon::network::integration

Definition forward.h:111

Definition at line 15 of file thread_pool_bridge.cpp.

    : pool_(std::move(pool)), backend_type_(backend_type) {
    if (!pool_) {
        throw std::invalid_argument("ThreadPoolBridge requires non-null thread pool");
    }
}

References pool_.

◆ ~ThreadPoolBridge()

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

override

Destructor.

Automatically calls shutdown() if initialized

Definition at line 24 of file thread_pool_bridge.cpp.

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

References initialized_, and shutdown().

Here is the call graph for this function:

Member Function Documentation

◆ from_thread_system()

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

static

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 125 of file thread_pool_bridge.cpp.

                                {
    (void)pool_name; // Pool name is informational only in current implementation
 
    auto pool = thread_integration_manager::instance().get_thread_pool();
    if (!pool) {
        throw std::runtime_error("Failed to get thread pool from thread_integration_manager");
    }
 
    return std::make_shared<ThreadPoolBridge>(pool, BackendType::ThreadSystem);
}

References kcenon::network::integration::thread_integration_manager::get_thread_pool(), kcenon::network::integration::thread_integration_manager::instance(), 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 121 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 93 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 117 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 30 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 89 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 73 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();
}