kcenon::thread::queue_capabilities_interface Class Reference

Mixin interface for queue capability introspection. More...

#include <queue_capabilities_interface.h>

Inheritance diagram for kcenon::thread::queue_capabilities_interface:

Collaboration diagram for kcenon::thread::queue_capabilities_interface:

Public Member Functions
virtual	~queue_capabilities_interface ()=default
virtual auto	get_capabilities () const -> queue_capabilities
	Get capabilities of this queue implementation.
auto	has_exact_size () const -> bool
	Check if size() returns exact values.
auto	has_atomic_empty () const -> bool
	Check if empty() check is atomic.
auto	is_lock_free () const -> bool
	Check if this is a lock-free implementation.
auto	is_wait_free () const -> bool
	Check if this is a wait-free implementation.
auto	supports_batch () const -> bool
	Check if batch operations are supported.
auto	supports_blocking_wait () const -> bool
	Check if blocking wait is supported.
auto	supports_stop () const -> bool
	Check if stop signaling is supported.

Detailed Description

Mixin interface for queue capability introspection.

This interface provides runtime capability queries for queue implementations. Classes can optionally inherit from this to expose their capabilities, enabling consumers to adapt their behavior accordingly.

Non-Breaking Addition

This is an additive interface. Existing code that doesn't use this interface continues to work unchanged. New code can optionally check for capabilities using dynamic_cast or other type checking mechanisms.

Thread Safety

All methods in this interface are const and return by value, making them inherently thread-safe. Implementations should not introduce mutable state.

Usage Example

// Check if queue supports exact size (new code)
if (auto* cap = dynamic_cast<queue_capabilities_interface*>(queue.get())) {
    if (cap->has_exact_size()) {
        // Safe to use size() for decisions
        auto count = queue->size();
    }
}
 
// Existing code continues to work (unchanged)
queue->enqueue(std::make_unique<my_job>());

Examples

queue_capabilities_sample.cpp.

Definition at line 50 of file queue_capabilities_interface.h.

Constructor & Destructor Documentation

~queue_capabilities_interface()

virtual kcenon::thread::queue_capabilities_interface::~queue_capabilities_interface ( )

virtualdefault

Member Function Documentation

get_capabilities()

virtual auto kcenon::thread::queue_capabilities_interface::get_capabilities ( ) const -> queue_capabilities

inlinenodiscardvirtual

Get capabilities of this queue implementation.

Returns

Queue capabilities struct describing this implementation

Default Implementation

Returns capabilities matching mutex-based job_queue behavior, ensuring backward compatibility for implementations that don't override.

Reimplemented in kcenon::thread::adaptive_job_queue, kcenon::thread::detail::lockfree_job_queue, kcenon::thread::job_queue, and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >.

Definition at line 62 of file queue_capabilities_interface.h.

                                                                              {
        return queue_capabilities{}; // Defaults match job_queue
    }

Referenced by has_atomic_empty(), has_exact_size(), is_lock_free(), is_wait_free(), supports_batch(), supports_blocking_wait(), and supports_stop().

Here is the caller graph for this function:

has_atomic_empty()

auto kcenon::thread::queue_capabilities_interface::has_atomic_empty ( ) const -> bool

inlinenodiscard

Check if empty() check is atomic.

Returns

true if empty() provides consistent atomic check

Definition at line 80 of file queue_capabilities_interface.h.

                                                        {
        return get_capabilities().atomic_empty_check;
    }

References get_capabilities().

Here is the call graph for this function:

has_exact_size()

auto kcenon::thread::queue_capabilities_interface::has_exact_size ( ) const -> bool

inlinenodiscard

Check if size() returns exact values.

Returns

true if size() provides accurate count

Lock-free queues may return approximate sizes due to concurrent modifications.

Definition at line 72 of file queue_capabilities_interface.h.

                                                      {
        return get_capabilities().exact_size;
    }

References get_capabilities().

Here is the call graph for this function:

is_lock_free()

auto kcenon::thread::queue_capabilities_interface::is_lock_free ( ) const -> bool

inlinenodiscard

Check if this is a lock-free implementation.

Returns

true if the queue uses lock-free algorithms

Lock-free implementations provide better performance under high contention but may have different semantics for size/empty checks.

Definition at line 91 of file queue_capabilities_interface.h.

                                                    {
        return get_capabilities().lock_free;
    }

References get_capabilities().

Here is the call graph for this function:

is_wait_free()

auto kcenon::thread::queue_capabilities_interface::is_wait_free ( ) const -> bool

inlinenodiscard

Check if this is a wait-free implementation.

Returns

true if the queue uses wait-free algorithms

Wait-free is a stronger guarantee than lock-free, ensuring bounded execution time for all operations regardless of contention.

Definition at line 102 of file queue_capabilities_interface.h.

                                                    {
        return get_capabilities().wait_free;
    }

References get_capabilities().

Here is the call graph for this function:

supports_batch()

auto kcenon::thread::queue_capabilities_interface::supports_batch ( ) const -> bool

inlinenodiscard

Check if batch operations are supported.

Returns

true if the queue supports batch enqueue/dequeue

Definition at line 110 of file queue_capabilities_interface.h.

                                                      {
        return get_capabilities().supports_batch;
    }

References get_capabilities().

Here is the call graph for this function:

supports_blocking_wait()

auto kcenon::thread::queue_capabilities_interface::supports_blocking_wait ( ) const -> bool

inlinenodiscard

Check if blocking wait is supported.

Returns

true if the queue supports blocking dequeue operations

Definition at line 118 of file queue_capabilities_interface.h.

                                                              {
        return get_capabilities().supports_blocking_wait;
    }

References get_capabilities().

Here is the call graph for this function:

supports_stop()

auto kcenon::thread::queue_capabilities_interface::supports_stop ( ) const -> bool

inlinenodiscard

Check if stop signaling is supported.

Returns

true if the queue supports stop() method for shutdown

Definition at line 126 of file queue_capabilities_interface.h.

                                                     {
        return get_capabilities().supports_stop;
    }

References get_capabilities().

Here is the call graph for this function:

---

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

• include/kcenon/thread/interfaces/queue_capabilities_interface.h