thread_pool_adapter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#ifdef USE_THREAD_SYSTEM
    // thread_system is available - use high-performance implementation
    #include <kcenon/thread/core/thread_pool.h>
    #include <kcenon/thread/core/typed_thread_pool.h>
    #include <kcenon/thread/core/job.h>
    #include <kcenon/thread/interfaces/thread_context.h>
    // Note: thread_system v3.0 removes monitoring_interface.h
    // Use common_system interfaces instead
    #include <kcenon/common/interfaces/logger_interface.h>
    #include <kcenon/common/interfaces/monitoring_interface.h>
 
    namespace database::async {
        using thread_pool_type = kcenon::thread::thread_pool;
 
        template<typename JobType = kcenon::thread::job_types>
        using typed_thread_pool_type = kcenon::thread::typed_thread_pool_t<JobType>;
 
        using job_type = kcenon::thread::job;
 
        template<typename JobType>
        using typed_job_type = kcenon::thread::typed_job_t<JobType>;
 
        using thread_context_type = kcenon::thread::thread_context;
 
        using monitoring_interface_type = kcenon::common::interfaces::IMonitor;
 
        using logger_interface_type = kcenon::common::interfaces::ILogger;
 
        template<typename T>
        using result_type = kcenon::common::Result<T>;
 
        using result_void_type = kcenon::common::VoidResult;
 
        constexpr bool using_thread_system = true;
 
    } // namespace database::async
 
#else
    // Fallback to standard library threading
    #include <thread>
    #include <mutex>
    #include <condition_variable>
    #include <atomic>
    #include <queue>
    #include <functional>
    #include <memory>
    #include <variant>
    #include <string>
 
    namespace database::async {
        class fallback_context {
        public:
            fallback_context() = default;
            ~fallback_context() = default;
            fallback_context(const fallback_context&) = default;
            fallback_context& operator=(const fallback_context&) = default;
            fallback_context(fallback_context&&) = default;
            fallback_context& operator=(fallback_context&&) = default;
        };
 
        // Forward declarations for fallback implementations
        class fallback_thread_pool;
        class fallback_job;
 
        using thread_pool_type = fallback_thread_pool;
 
        template<typename JobType>
        using typed_thread_pool_type = fallback_thread_pool;
 
        using job_type = fallback_job;
 
        template<typename JobType>
        using typed_job_type = fallback_job;
 
        using thread_context_type = fallback_context;
 
        using monitoring_interface_type = void;
 
        using logger_interface_type = void;
 
        template<typename T>
        class result_type {
        public:
            result_type(T&& value) : value_(std::forward<T>(value)), has_value_(true) {}
            result_type(const T& value) : value_(value), has_value_(true) {}
            result_type(const std::string& error) : error_(error), has_value_(false) {}
 
            bool is_ok() const { return has_value_; }
            bool has_error() const { return !has_value_; }
 
            const T& value() const { return value_; }
            T& value() { return value_; }
 
            const std::string& error() const { return error_; }
 
        private:
            T value_;
            std::string error_;
            bool has_value_;
        };
 
        class result_void_type {
        public:
            result_void_type() : has_error_(false) {}
            result_void_type(const std::string& error) : error_(error), has_error_(true) {}
 
            bool is_ok() const { return !has_error_; }
            bool has_error() const { return has_error_; }
            const std::string& error() const { return error_; }
 
        private:
            std::string error_;
            bool has_error_;
        };
 
        constexpr bool using_thread_system = false;
 
    } // namespace database::async
 
#endif // USE_THREAD_SYSTEM