queue_factory.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/thread/core/job_queue.h>
#include <kcenon/thread/lockfree/lockfree_job_queue.h>
#include <kcenon/thread/queue/adaptive_job_queue.h>
#include <kcenon/thread/interfaces/scheduler_interface.h>
#include <kcenon/thread/interfaces/queue_traits.h>
#include <kcenon/thread/policies/policy_queue.h>
 
#include <memory>
#include <type_traits>
 
namespace kcenon::thread {
 
class queue_factory {
public:
    struct requirements {
        bool need_exact_size = false;       
        bool need_atomic_empty = false;     
        bool prefer_lock_free = false;      
        bool need_batch_operations = false; 
        bool need_blocking_wait = false;    
    };
 
    // ============================================
    // Convenience factory methods
    // ============================================
 
    [[nodiscard]] static auto create_standard_queue() -> std::shared_ptr<job_queue> {
        return std::make_shared<job_queue>();
    }
 
    [[nodiscard]] static auto create_adaptive_queue(
        adaptive_job_queue::policy policy = adaptive_job_queue::policy::balanced)
        -> std::unique_ptr<adaptive_job_queue>
    {
        return std::make_unique<adaptive_job_queue>(policy);
    }
 
    // ============================================
    // Requirements-based factory method
    // ============================================
 
    [[nodiscard]] static auto create_for_requirements(const requirements& reqs)
        -> std::unique_ptr<scheduler_interface>;
 
    // ============================================
    // Environment-based auto-selection
    // ============================================
 
    [[nodiscard]] static auto create_optimal() -> std::unique_ptr<scheduler_interface>;
 
    // ============================================
    // Policy-based queue factory methods
    // ============================================
 
    [[nodiscard]] static auto create_policy_queue()
        -> std::unique_ptr<standard_queue>;
 
    [[nodiscard]] static auto create_lockfree_policy_queue()
        -> std::unique_ptr<policy_lockfree_queue>;
 
    [[nodiscard]] static auto create_bounded_policy_queue(std::size_t max_size)
        -> std::unique_ptr<policy_queue<
            policies::mutex_sync_policy,
            policies::bounded_policy,
            policies::overflow_reject_policy>>;
 
    template<typename SyncPolicy, typename BoundPolicy, typename OverflowPolicy>
    [[nodiscard]] static auto create_custom_policy_queue(
        SyncPolicy sync_policy,
        BoundPolicy bound_policy,
        OverflowPolicy overflow_policy)
        -> std::unique_ptr<policy_queue<SyncPolicy, BoundPolicy, OverflowPolicy>>
    {
        static_assert(is_sync_policy_v<SyncPolicy>,
            "SyncPolicy must be a valid sync policy type");
        static_assert(is_bound_policy_v<BoundPolicy>,
            "BoundPolicy must be a valid bound policy type");
        static_assert(is_overflow_policy_v<OverflowPolicy>,
            "OverflowPolicy must be a valid overflow policy type");
 
        return std::make_unique<policy_queue<SyncPolicy, BoundPolicy, OverflowPolicy>>(
            std::move(sync_policy),
            std::move(bound_policy),
            std::move(overflow_policy)
        );
    }
};
 
// ============================================
// Compile-time selection utilities
// ============================================
 
template<bool NeedExactSize, bool PreferLockFree = false>
struct queue_type_selector {
    static_assert(!(NeedExactSize && PreferLockFree),
        "Cannot require both exact size AND lock-free. These are mutually exclusive. "
        "Lock-free queues cannot provide exact size due to concurrent modifications.");
 
    // Both PreferLockFree and default case now use adaptive_job_queue
    // (lockfree_job_queue is an internal implementation detail)
    using type = std::conditional_t<
        NeedExactSize,
        job_queue,
        adaptive_job_queue
    >;
};
 
template<bool NeedExactSize, bool PreferLockFree = false>
using queue_t = typename queue_type_selector<NeedExactSize, PreferLockFree>::type;
 
// ============================================
// Pre-defined type aliases
// ============================================
 
using accurate_queue_t = queue_t<true, false>;
 
using fast_queue_t = queue_t<false, true>;
 
using balanced_queue_t = queue_t<false, false>;
 
} // namespace kcenon::thread