queue_traits.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
 
#include <type_traits>
 
namespace kcenon::thread {
 
// Forward declarations
class scheduler_interface;
class queue_capabilities_interface;
 
template<typename SyncPolicy, typename BoundPolicy, typename OverflowPolicy>
class policy_queue;
 
namespace policies {
    struct sync_policy_tag;
    struct bound_policy_tag;
    struct overflow_policy_tag;
}
 
// ============================================
// Policy detection traits
// ============================================
 
namespace detail {
 
template<typename T, typename = void>
struct has_sync_policy_tag : std::false_type {};
 
template<typename T>
struct has_sync_policy_tag<T, std::void_t<typename T::policy_tag>>
    : std::is_same<typename T::policy_tag, policies::sync_policy_tag> {};
 
template<typename T, typename = void>
struct has_bound_policy_tag : std::false_type {};
 
template<typename T>
struct has_bound_policy_tag<T, std::void_t<typename T::policy_tag>>
    : std::is_same<typename T::policy_tag, policies::bound_policy_tag> {};
 
template<typename T, typename = void>
struct has_overflow_policy_tag : std::false_type {};
 
template<typename T>
struct has_overflow_policy_tag<T, std::void_t<typename T::policy_tag>>
    : std::is_same<typename T::policy_tag, policies::overflow_policy_tag> {};
 
} // namespace detail
 
// ============================================
// Policy type concepts (SFINAE-style)
// ============================================
 
template<typename T>
constexpr bool is_sync_policy_v = detail::has_sync_policy_tag<T>::value;
 
template<typename T>
constexpr bool is_bound_policy_v = detail::has_bound_policy_tag<T>::value;
 
template<typename T>
constexpr bool is_overflow_policy_v = detail::has_overflow_policy_tag<T>::value;
 
// ============================================
// Queue type detection traits
// ============================================
 
namespace detail {
 
template<typename T>
struct is_policy_queue_impl : std::false_type {};
 
template<typename SyncPolicy, typename BoundPolicy, typename OverflowPolicy>
struct is_policy_queue_impl<policy_queue<SyncPolicy, BoundPolicy, OverflowPolicy>>
    : std::true_type {};
 
template<typename T, typename = void>
struct has_sync_policy_type : std::false_type {};
 
template<typename T>
struct has_sync_policy_type<T, std::void_t<typename T::sync_policy_type>>
    : std::true_type {};
 
template<typename T, typename = void>
struct has_bound_policy_type : std::false_type {};
 
template<typename T>
struct has_bound_policy_type<T, std::void_t<typename T::bound_policy_type>>
    : std::true_type {};
 
template<typename T, typename = void>
struct has_overflow_policy_type : std::false_type {};
 
template<typename T>
struct has_overflow_policy_type<T, std::void_t<typename T::overflow_policy_type>>
    : std::true_type {};
 
} // namespace detail
 
template<typename T>
constexpr bool is_policy_queue_v = detail::is_policy_queue_impl<std::remove_cv_t<T>>::value;
 
template<typename T>
constexpr bool is_scheduler_v = std::is_base_of_v<scheduler_interface, std::remove_cv_t<T>>;
 
template<typename T>
constexpr bool is_queue_capabilities_v =
    std::is_base_of_v<queue_capabilities_interface, std::remove_cv_t<T>>;
 
// ============================================
// Policy extraction traits
// ============================================
 
template<typename T, typename = void>
struct policy_queue_traits {
    static constexpr bool is_policy_queue = false;
};
 
template<typename T>
struct policy_queue_traits<T, std::enable_if_t<
    detail::has_sync_policy_type<T>::value &&
    detail::has_bound_policy_type<T>::value &&
    detail::has_overflow_policy_type<T>::value>>
{
    static constexpr bool is_policy_queue = true;
 
    using sync_policy_type = typename T::sync_policy_type;
    using bound_policy_type = typename T::bound_policy_type;
    using overflow_policy_type = typename T::overflow_policy_type;
};
 
// ============================================
// Queue capability detection
// ============================================
 
template<typename T, typename = void>
struct is_lockfree_queue : std::false_type {};
 
template<typename T>
struct is_lockfree_queue<T, std::enable_if_t<policy_queue_traits<T>::is_policy_queue>>
{
    static constexpr bool value =
        policy_queue_traits<T>::sync_policy_type::get_capabilities().lock_free;
};
 
template<typename T>
constexpr bool is_lockfree_queue_v = is_lockfree_queue<T>::value;
 
template<typename T, typename = void>
struct is_bounded_queue : std::false_type {};
 
template<typename T>
struct is_bounded_queue<T, std::enable_if_t<policy_queue_traits<T>::is_policy_queue>>
{
    static constexpr bool value =
        policy_queue_traits<T>::bound_policy_type::is_bounded();
};
 
template<typename T>
constexpr bool is_bounded_queue_v = is_bounded_queue<T>::value;
 
template<typename T, typename = void>
struct has_blocking_overflow : std::false_type {};
 
template<typename T>
struct has_blocking_overflow<T, std::enable_if_t<policy_queue_traits<T>::is_policy_queue>>
{
    static constexpr bool value =
        policy_queue_traits<T>::overflow_policy_type::blocks();
};
 
template<typename T>
constexpr bool has_blocking_overflow_v = has_blocking_overflow<T>::value;
 
} // namespace kcenon::thread