thread_system_adapter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/network/detail/config/feature_flags.h>
 
#include "kcenon/network/integration/thread_integration.h"
#include <kcenon/network/detail/utils/result_types.h>
#include <memory>
#include <future>
#include <string>
#include <functional>
#include <chrono>
 
#if KCENON_WITH_THREAD_SYSTEM
// Suppress deprecation warnings from thread_system headers
#  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
// Include format for thread_system headers that use std::format
#  include <format>
#  include <kcenon/thread/core/thread_pool.h>
#  include <kcenon/thread/interfaces/thread_context.h>
#  include <kcenon/thread/interfaces/service_container.h>
#  pragma clang diagnostic pop
#endif
 
namespace kcenon::network::integration {
 
#if KCENON_WITH_THREAD_SYSTEM
 
class thread_system_pool_adapter : public thread_pool_interface {
public:
    [[nodiscard]] static Result<std::shared_ptr<thread_system_pool_adapter>> create(
        std::shared_ptr<kcenon::thread::thread_pool> pool);
    ~thread_system_pool_adapter();
 
    // Non-copyable, non-movable
    thread_system_pool_adapter(const thread_system_pool_adapter&) = delete;
    thread_system_pool_adapter& operator=(const thread_system_pool_adapter&) = delete;
    thread_system_pool_adapter(thread_system_pool_adapter&&) = delete;
    thread_system_pool_adapter& operator=(thread_system_pool_adapter&&) = delete;
 
    // thread_pool_interface
    std::future<void> submit(std::function<void()> task) override;
    std::future<void> submit_delayed(std::function<void()> task,
                                     std::chrono::milliseconds delay) override;
    size_t worker_count() const override;
    bool is_running() const override;
    size_t pending_tasks() const override;
 
    // Convenience helpers
    static std::shared_ptr<thread_system_pool_adapter> create_default(
        const std::string& pool_name = "network_pool");
 
    // Try resolving from thread_system's service_container; fallback to default
    static std::shared_ptr<thread_system_pool_adapter> from_service_or_default(
        const std::string& pool_name = "network_pool");
 
private:
    explicit thread_system_pool_adapter(std::shared_ptr<kcenon::thread::thread_pool> pool);
    std::shared_ptr<kcenon::thread::thread_pool> pool_;
};
 
bool bind_thread_system_pool_into_manager(const std::string& pool_name = "network_pool");
 
#else // KCENON_WITH_THREAD_SYSTEM
 
// Placeholder when thread_system is not available, to keep includes harmless
struct thread_system_pool_adapter_unavailable final {
    thread_system_pool_adapter_unavailable() = delete;
};
 
#endif // KCENON_WITH_THREAD_SYSTEM
 
} // namespace kcenon::network::integration