kcenon::thread::adapters::thread_pool_executor_adapter Class Reference

Adapter exposing thread_pool through common::interfaces::IExecutor. More...

#include <common_executor_adapter.h>

Inheritance diagram for kcenon::thread::adapters::thread_pool_executor_adapter:

Collaboration diagram for kcenon::thread::adapters::thread_pool_executor_adapter:

Public Member Functions
	thread_pool_executor_adapter (std::shared_ptr< kcenon::thread::thread_pool > pool)
std::future< void >	submit (std::function< void()> task)
std::future< void >	submit_delayed (std::function< void()> task, std::chrono::milliseconds delay)
common::Result< std::future< void > >	execute (std::unique_ptr< common::interfaces::IJob > &&job) override
common::Result< std::future< void > >	execute_delayed (std::unique_ptr< common::interfaces::IJob > &&job, std::chrono::milliseconds delay) override
size_t	worker_count () const override
bool	is_running () const override
size_t	pending_tasks () const override
void	shutdown (bool wait_for_completion=true) override
std::shared_ptr< kcenon::thread::thread_pool >	get_thread_pool () const

Private Attributes
std::shared_ptr< kcenon::thread::thread_pool >	pool_

Detailed Description

Adapter exposing thread_pool through common::interfaces::IExecutor.

This is the recommended way to use thread_pool with the IExecutor interface. It provides a clean separation between thread_pool's core functionality and the IExecutor interface contract.

Example Usage

#include <kcenon/thread/core/thread_pool.h>
#include <kcenon/thread/adapters/common_executor_adapter.h>
 
// Create and configure the thread pool
auto pool = std::make_shared<kcenon::thread::thread_pool>("my_pool");
pool->enqueue(std::make_unique<kcenon::thread::thread_worker>());
pool->start();
 
// Create the adapter for IExecutor compatibility
auto executor = std::make_shared<kcenon::thread::adapters::thread_pool_executor_adapter>(pool);
 
// Use through IExecutor interface
auto future = executor->execute(std::make_unique<MyJob>());

Note

The adapter holds a shared_ptr to the thread_pool, ensuring the pool remains alive as long as the adapter exists.

Definition at line 282 of file common_executor_adapter.h.

Constructor & Destructor Documentation

thread_pool_executor_adapter()

kcenon::thread::adapters::thread_pool_executor_adapter::thread_pool_executor_adapter ( std::shared_ptr< kcenon::thread::thread_pool > pool )

inlineexplicit

Definition at line 284 of file common_executor_adapter.h.

        : pool_(std::move(pool)) {}

Member Function Documentation

execute()

common::Result< std::future< void > > kcenon::thread::adapters::thread_pool_executor_adapter::execute ( std::unique_ptr< common::interfaces::IJob > && job )

inlineoverride

Definition at line 315 of file common_executor_adapter.h.

                                                                                              {
        auto shared_job = std::shared_ptr<common::interfaces::IJob>(std::move(job));
        return detail::schedule_task(pool_,
            [shared_job]() mutable -> common::VoidResult {
                try {
                    auto result = shared_job->execute();
                    if (result.is_err()) {
                        return detail::make_error(result.error());
                    }
                    return common::ok();
                } catch (const std::exception& ex) {
                    return detail::make_error(
                        kcenon::thread::error_code::job_execution_failed,
                        ex.what());
                } catch (...) {
                    return detail::make_error(
                        kcenon::thread::error_code::job_execution_failed,
                        "Unknown exception while executing common job");
                }
            });
    }

References kcenon::thread::job_execution_failed, kcenon::thread::adapters::detail::make_error(), pool_, and kcenon::thread::adapters::detail::schedule_task().

Here is the call graph for this function:

execute_delayed()

common::Result< std::future< void > > kcenon::thread::adapters::thread_pool_executor_adapter::execute_delayed ( std::unique_ptr< common::interfaces::IJob > && job, std::chrono::milliseconds delay )

inlineoverride

Definition at line 337 of file common_executor_adapter.h.

                                              {
        auto promise = std::make_shared<std::promise<void>>();
        auto future = promise->get_future();
        auto shared_job = std::shared_ptr<common::interfaces::IJob>(std::move(job));
 
        detail::schedule_task_async(pool_, promise,
            [shared_job]() mutable -> common::VoidResult {
                try {
                    auto result = shared_job->execute();
                    if (result.is_err()) {
                        return detail::make_error(result.error());
                    }
                    return common::ok();
                } catch (const std::exception& ex) {
                    return detail::make_error(
                        kcenon::thread::error_code::job_execution_failed,
                        ex.what());
                } catch (...) {
                    return detail::make_error(
                        kcenon::thread::error_code::job_execution_failed,
                        "Unknown exception while executing common job");
                }
            },
            delay);
 
        return common::Result<std::future<void>>::ok(std::move(future));
    }

References kcenon::thread::delay, kcenon::thread::job_execution_failed, kcenon::thread::adapters::detail::make_error(), pool_, and kcenon::thread::adapters::detail::schedule_task_async().

Here is the call graph for this function:

get_thread_pool()

std::shared_ptr< kcenon::thread::thread_pool > kcenon::thread::adapters::thread_pool_executor_adapter::get_thread_pool ( ) const

inline

Definition at line 392 of file common_executor_adapter.h.

                                                                   {
        return pool_;
    }

References pool_.

is_running()

bool kcenon::thread::adapters::thread_pool_executor_adapter::is_running ( ) const

inlineoverride

Definition at line 371 of file common_executor_adapter.h.

                                     {
        return pool_ && pool_->is_running();
    }

References kcenon::thread::thread_pool::is_running(), and pool_.

Here is the call graph for this function:

pending_tasks()

size_t kcenon::thread::adapters::thread_pool_executor_adapter::pending_tasks ( ) const

inlineoverride

Definition at line 375 of file common_executor_adapter.h.

                                          {
        return pool_ ? pool_->get_pending_task_count() : 0U;
    }

References kcenon::thread::thread_pool::get_pending_task_count(), and pool_.

Here is the call graph for this function:

shutdown()

void kcenon::thread::adapters::thread_pool_executor_adapter::shutdown ( bool wait_for_completion = true )

inlineoverride

Definition at line 379 of file common_executor_adapter.h.

                                                            {
        if (!pool_) {
            return;
        }
 
        auto stop_result = pool_->stop(!wait_for_completion);
        if (stop_result.is_err()) {
            // Best effort: surface error via exception to aid debugging.
            const auto& err = stop_result.error();
            throw std::runtime_error(err.message);
        }
    }

References pool_, and kcenon::thread::thread_pool::stop().

Here is the call graph for this function:

submit()

std::future< void > kcenon::thread::adapters::thread_pool_executor_adapter::submit ( std::function< void()> task )

inline

Definition at line 287 of file common_executor_adapter.h.

                                                     {
        auto result = detail::schedule_task(pool_, [task = std::move(task)]() mutable {
            return detail::wrap_user_task(task);
        });
 
        if (result.is_ok()) {
            return std::move(result.unwrap());
        }
 
        std::promise<void> failed;
        failed.set_exception(detail::to_exception(result.error()));
        return failed.get_future();
    }

References kcenon::thread::failed, kcenon::thread::result< T >::is_ok(), pool_, kcenon::thread::adapters::detail::schedule_task(), kcenon::thread::adapters::detail::to_exception(), and kcenon::thread::adapters::detail::wrap_user_task().

Here is the call graph for this function:

submit_delayed()

std::future< void > kcenon::thread::adapters::thread_pool_executor_adapter::submit_delayed ( std::function< void()> task, std::chrono::milliseconds delay )

inline

Definition at line 301 of file common_executor_adapter.h.

                                                                  {
        auto promise = std::make_shared<std::promise<void>>();
        auto future = promise->get_future();
 
        detail::schedule_task_async(pool_, promise,
            [task = std::move(task)]() mutable {
                return detail::wrap_user_task(task);
            },
            delay);
 
        return future;
    }

References kcenon::thread::delay, pool_, kcenon::thread::adapters::detail::schedule_task_async(), and kcenon::thread::adapters::detail::wrap_user_task().

Here is the call graph for this function:

worker_count()

size_t kcenon::thread::adapters::thread_pool_executor_adapter::worker_count ( ) const

inlineoverride

Definition at line 367 of file common_executor_adapter.h.

                                         {
        return pool_ ? pool_->get_active_worker_count() : 0U;
    }

References kcenon::thread::thread_pool::get_active_worker_count(), and pool_.

Here is the call graph for this function:

Member Data Documentation

pool_

std::shared_ptr<kcenon::thread::thread_pool> kcenon::thread::adapters::thread_pool_executor_adapter::pool_

private

Definition at line 397 of file common_executor_adapter.h.

Referenced by execute(), execute_delayed(), get_thread_pool(), is_running(), pending_tasks(), shutdown(), submit(), submit_delayed(), and worker_count().

---

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

• include/kcenon/thread/adapters/common_executor_adapter.h