Policy-based queue template. More...

#include <policy_queue.h>

Inheritance diagram for kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >:

Collaboration diagram for kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >:

Public Types
using	sync_policy_type = SyncPolicy

using	bound_policy_type = BoundPolicy

using	overflow_policy_type = OverflowPolicy

Public Member Functions
	policy_queue ()
	Construct queue with default policies.

	policy_queue (BoundPolicy bound_policy)
	Construct queue with bound policy.

	policy_queue (SyncPolicy sync_policy, BoundPolicy bound_policy, OverflowPolicy overflow_policy)
	Construct queue with all policies.

	~policy_queue ()=default
	Destructor.

	policy_queue (const policy_queue &)=delete

policy_queue &	operator= (const policy_queue &)=delete

	policy_queue (policy_queue &&)=delete

policy_queue &	operator= (policy_queue &&)=delete

auto	schedule (std::unique_ptr< job > &&work) -> common::VoidResult override
	Schedule a job (delegates to enqueue)

auto	get_next_job () -> common::Result< std::unique_ptr< job > > override
	Get next job (delegates to dequeue)

auto	enqueue (std::unique_ptr< job > &&value) -> common::VoidResult
	Enqueue a job into the queue.

template<typename JobType , typename = std::enable_if_t<std::is_base_of_v<job, JobType>>>
auto	enqueue (std::unique_ptr< JobType > &&value) -> common::VoidResult
	Type-safe enqueue for job subclasses.

auto	dequeue () -> common::Result< std::unique_ptr< job > >
	Dequeue a job (blocking if sync policy supports it)

auto	try_dequeue () -> common::Result< std::unique_ptr< job > >
	Try to dequeue a job (non-blocking)

auto	empty () const -> bool
	Check if queue is empty.

auto	size () const -> std::size_t
	Get queue size.

auto	clear () -> void
	Clear all jobs from queue.

auto	stop () -> void
	Stop the queue.

auto	is_stopped () const -> bool
	Check if queue is stopped.

auto	get_capabilities () const -> queue_capabilities override
	Get queue capabilities.

auto	sync_policy () -> SyncPolicy &
	Get reference to sync policy.

auto	sync_policy () const -> const SyncPolicy &
	Get const reference to sync policy.

auto	bound_policy () -> BoundPolicy &
	Get reference to bound policy.

auto	bound_policy () const -> const BoundPolicy &
	Get const reference to bound policy.

auto	overflow_policy () -> OverflowPolicy &
	Get reference to overflow policy.

auto	overflow_policy () const -> const OverflowPolicy &
	Get const reference to overflow policy.

auto	is_bounded () const -> bool
	Check if queue is bounded.

auto	is_full () const -> bool
	Check if queue is at capacity.

auto	remaining_capacity () const -> std::size_t
	Get remaining capacity.

Public Member Functions inherited from kcenon::thread::scheduler_interface
virtual	~scheduler_interface ()=default

Public Member Functions inherited from kcenon::thread::queue_capabilities_interface
virtual	~queue_capabilities_interface ()=default

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.

Private Member Functions
auto	handle_overflow (std::unique_ptr< job > &&value) -> common::VoidResult
	Handle overflow based on overflow policy.

Private Attributes
SyncPolicy	sync_policy_

BoundPolicy	bound_policy_

OverflowPolicy	overflow_policy_

Detailed Description

template<typename SyncPolicy, typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>
class kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >

Policy-based queue template.

Policy-based job queue template with customizable behavior.

This template class provides a flexible job queue where synchronization, bounding, and overflow behaviors are controlled by policy classes.

Template Parameters

SyncPolicy: Controls thread synchronization (mutex, lock-free, adaptive)
BoundPolicy: Controls queue size limits (bounded, unbounded)
OverflowPolicy: Controls behavior when queue is full (reject, block, drop)

Design Pattern

Uses compile-time policy-based design for:

Zero-overhead abstractions (no virtual dispatch for policies)
Type-safe policy combinations
Explicit capability documentation

Thread Safety

Thread safety depends on the SyncPolicy:

mutex_sync_policy: Full thread safety with blocking support
lockfree_sync_policy: Thread-safe without blocking
adaptive_sync_policy: Configurable thread safety

Usage Example

// Bounded queue with mutex sync and blocking on overflow
using my_queue = policy_queue<
    policies::mutex_sync_policy,
    policies::bounded_policy,
    policies::overflow_block_policy
>;
 
my_queue queue(policies::bounded_policy(1000));
queue.enqueue(std::make_unique<my_job>());
auto job = queue.dequeue();

Policy Compatibility Matrix

SyncPolicy	BoundPolicy	OverflowPolicy	Compatible
mutex	any	any	Yes
lockfree	unbounded	N/A	Yes
lockfree	bounded	reject/drop	Yes
lockfree	bounded	block	No
adaptive	any	any	Yes

Template Parameters

SyncPolicy	Synchronization policy type
BoundPolicy	Bounding policy type (default: unbounded_policy)
OverflowPolicy	Overflow handling policy type (default: overflow_reject_policy)

Definition at line 83 of file policy_queue.h.

Member Typedef Documentation

◆ bound_policy_type

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

using kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_type = BoundPolicy

Definition at line 87 of file policy_queue.h.

◆ overflow_policy_type

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

using kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy_type = OverflowPolicy

Definition at line 88 of file policy_queue.h.

◆ sync_policy_type

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

using kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_type = SyncPolicy

Definition at line 86 of file policy_queue.h.

Constructor & Destructor Documentation

◆ policy_queue() [1/5]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::policy_queue ( )

inline

Construct queue with default policies.

Definition at line 97 of file policy_queue.h.

        : sync_policy_()
        , bound_policy_()
        , overflow_policy_() {}

◆ policy_queue() [2/5]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::policy_queue ( BoundPolicy bound_policy )

inlineexplicit

Construct queue with bound policy.

Parameters

bound_policy Bound policy configuration

Definition at line 106 of file policy_queue.h.

        : sync_policy_()
        , bound_policy_(std::move(bound_policy))
        , overflow_policy_() {}

◆ policy_queue() [3/5]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::policy_queue	(	SyncPolicy	sync_policy,
		BoundPolicy	bound_policy,
		OverflowPolicy	overflow_policy )

inline

Construct queue with all policies.

Parameters

sync_policy	Sync policy configuration
bound_policy	Bound policy configuration
overflow_policy	Overflow policy configuration

Definition at line 117 of file policy_queue.h.

        : sync_policy_(std::move(sync_policy))
        , bound_policy_(std::move(bound_policy))
        , overflow_policy_(std::move(overflow_policy)) {}

◆ ~policy_queue()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::~policy_queue ( )

default

Destructor.

◆ policy_queue() [4/5]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::policy_queue ( const policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy > & )

delete

◆ policy_queue() [5/5]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::policy_queue ( policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy > && )

delete

Member Function Documentation

◆ bound_policy() [1/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy ( ) -> BoundPolicy&

inlinenodiscard

Get reference to bound policy.

Returns: Bound policy reference

Definition at line 285 of file policy_queue.h.

                                                      {
        return bound_policy_;
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_.

◆ bound_policy() [2/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy ( ) const -> const BoundPolicy&

inlinenodiscard

Get const reference to bound policy.

Returns: Bound policy const reference

Definition at line 293 of file policy_queue.h.

                                                                  {
        return bound_policy_;
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_.

◆ clear()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::clear ( ) -> void

inline

Clear all jobs from queue.

Definition at line 230 of file policy_queue.h.

                         {
        sync_policy_.clear();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ dequeue()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::dequeue ( ) -> common::Result<std::unique_ptr<job>>

inlinenodiscard

Dequeue a job (blocking if sync policy supports it)

Returns: Result containing the job or error

Definition at line 199 of file policy_queue.h.

                                                                     {
        return sync_policy_.dequeue();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

Referenced by kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::get_next_job().

Here is the caller graph for this function:

◆ empty()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::empty ( ) const -> bool

inlinenodiscard

Check if queue is empty.

Returns: true if empty

Definition at line 215 of file policy_queue.h.

                                             {
        return sync_policy_.empty();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ enqueue() [1/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::enqueue ( std::unique_ptr< job > && value ) -> common::VoidResult

inlinenodiscard

Enqueue a job into the queue.

Parameters

value Job to enqueue

Returns: VoidResult indicating success or error

Behavior depends on policies:

If queue is bounded and full, overflow policy is invoked
Sync policy controls thread safety

Definition at line 169 of file policy_queue.h.

                                                                               {
        if (!value) {
            return common::error_info{-105, "cannot enqueue null job", "thread_system"};
        }
 
        // Check bound policy
        if constexpr (BoundPolicy::is_bounded()) {
            if (bound_policy_.is_full(sync_policy_.size())) {
                return handle_overflow(std::move(value));
            }
        }
 
        return sync_policy_.enqueue(std::move(value));
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_, kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::handle_overflow(), and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

Referenced by kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::enqueue(), and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enqueue() [2/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

template<typename JobType , typename = std::enable_if_t<std::is_base_of_v<job, JobType>>>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::enqueue ( std::unique_ptr< JobType > && value ) -> common::VoidResult

inlinenodiscard

Type-safe enqueue for job subclasses.

Template Parameters

JobType A type derived from job

Parameters

value Job to enqueue

Returns: VoidResult indicating success or error

Definition at line 191 of file policy_queue.h.

                                                                                   {
        return enqueue(std::unique_ptr<job>(std::move(value)));
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::enqueue().

Here is the call graph for this function:

◆ get_capabilities()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::get_capabilities ( ) const -> queue_capabilities

inlinenodiscardoverridevirtual

Get queue capabilities.

Returns: Capabilities based on sync policy

Reimplemented from kcenon::thread::queue_capabilities_interface.

Definition at line 257 of file policy_queue.h.

                                                                               {
        return sync_policy_.get_capabilities();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ get_next_job()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::get_next_job ( ) -> common::Result<std::unique_ptr<job>>

inlineoverridevirtual

Get next job (delegates to dequeue)

Returns: common::Result<std::unique_ptr<job>> The dequeued job or error

Implements kcenon::thread::scheduler_interface.

Definition at line 152 of file policy_queue.h.

                                                                     {
        return dequeue();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::dequeue().

Here is the call graph for this function:

◆ handle_overflow()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::handle_overflow ( std::unique_ptr< job > && value ) -> common::VoidResult

inlinenodiscardprivate

Handle overflow based on overflow policy.

Parameters

value Job that triggered overflow

Returns: VoidResult from overflow handling

Definition at line 353 of file policy_queue.h.

                                                                                       {
        if constexpr (std::is_same_v<OverflowPolicy, policies::overflow_reject_policy>) {
            return overflow_policy_.handle_overflow(std::move(value));
        } else if constexpr (std::is_same_v<OverflowPolicy, policies::overflow_drop_newest_policy>) {
            return overflow_policy_.handle_overflow(std::move(value));
        } else if constexpr (std::is_same_v<OverflowPolicy, policies::overflow_drop_oldest_policy>) {
            // Drop oldest by dequeuing and discarding
            auto oldest = sync_policy_.try_dequeue();
            (void)oldest;  // Discard
            return sync_policy_.enqueue(std::move(value));
        } else {
            // For blocking policies, just return the error
            // Actual blocking must be implemented at a higher level
            return common::error_info{-120, "queue is full", "thread_system"};
        }
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy_, and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

Referenced by kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::enqueue().

Here is the caller graph for this function:

◆ is_bounded()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::is_bounded ( ) const -> bool

inlinenodiscard

Check if queue is bounded.

Returns: true if bound policy limits size

Definition at line 321 of file policy_queue.h.

                                                  {
        if constexpr (requires { bound_policy_.is_bounded(); }) {
            return bound_policy_.is_bounded();
        }
        return BoundPolicy::is_bounded();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_.

◆ is_full()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::is_full ( ) const -> bool

inlinenodiscard

Check if queue is at capacity.

Returns: true if bounded and at max size

Definition at line 332 of file policy_queue.h.

                                               {
        if constexpr (BoundPolicy::is_bounded()) {
            return bound_policy_.is_full(sync_policy_.size());
        }
        return false;
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_, and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ is_stopped()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::is_stopped ( ) const -> bool

inlinenodiscard

Check if queue is stopped.

Returns: true if stopped

Definition at line 245 of file policy_queue.h.

                                                  {
        return sync_policy_.is_stopped();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ operator=() [1/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

policy_queue & kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::operator= ( const policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy > & )

delete

◆ operator=() [2/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

policy_queue & kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::operator= ( policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy > && )

delete

◆ overflow_policy() [1/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy ( ) -> OverflowPolicy&

inlinenodiscard

Get reference to overflow policy.

Returns: Overflow policy reference

Definition at line 301 of file policy_queue.h.

                                                            {
        return overflow_policy_;
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy_.

◆ overflow_policy() [2/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy ( ) const -> const OverflowPolicy&

inlinenodiscard

Get const reference to overflow policy.

Returns: Overflow policy const reference

Definition at line 309 of file policy_queue.h.

                                                                        {
        return overflow_policy_;
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy_.

◆ remaining_capacity()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::remaining_capacity ( ) const -> std::size_t

inlinenodiscard

Get remaining capacity.

Returns: Number of items that can still be added

Definition at line 343 of file policy_queue.h.

                                                               {
        return bound_policy_.remaining_capacity(sync_policy_.size());
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_, and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ schedule()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::schedule ( std::unique_ptr< job > && work ) -> common::VoidResult

inlineoverridevirtual

Schedule a job (delegates to enqueue)

Parameters

work	Job to schedule

Returns: common::VoidResult Success or error

Implements kcenon::thread::scheduler_interface.

Definition at line 144 of file policy_queue.h.

                                                                          {
        return enqueue(std::move(work));
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::enqueue().

Here is the call graph for this function:

◆ size()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::size ( ) const -> std::size_t

inlinenodiscard

Get queue size.

Returns: Number of jobs in queue (exact or approximate based on sync policy)

Definition at line 223 of file policy_queue.h.

                                                 {
        return sync_policy_.size();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ stop()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::stop ( ) -> void

inline

Stop the queue.

Definition at line 237 of file policy_queue.h.

                        {
        sync_policy_.stop();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ sync_policy() [1/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy ( ) -> SyncPolicy&

inlinenodiscard

Get reference to sync policy.

Returns: Sync policy reference

Definition at line 269 of file policy_queue.h.

                                                    {
        return sync_policy_;
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ sync_policy() [2/2]

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy ( ) const -> const SyncPolicy&

inlinenodiscard

Get const reference to sync policy.

Returns: Sync policy const reference

Definition at line 277 of file policy_queue.h.

                                                                {
        return sync_policy_;
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

◆ try_dequeue()

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

auto kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::try_dequeue ( ) -> common::Result<std::unique_ptr<job>>

inlinenodiscard

Try to dequeue a job (non-blocking)

Returns: Result containing the job or error

Definition at line 207 of file policy_queue.h.

                                                                         {
        return sync_policy_.try_dequeue();
    }

References kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_.

Member Data Documentation

◆ bound_policy_

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

BoundPolicy kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy_

private

Definition at line 371 of file policy_queue.h.

Referenced by kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy(), kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::bound_policy(), kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::enqueue(), kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::is_bounded(), kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::is_full(), and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::remaining_capacity().

◆ overflow_policy_

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

OverflowPolicy kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy_

private

Definition at line 372 of file policy_queue.h.

Referenced by kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::handle_overflow(), kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy(), and kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::overflow_policy().

◆ sync_policy_

template<typename SyncPolicy , typename BoundPolicy = policies::unbounded_policy, typename OverflowPolicy = policies::overflow_reject_policy>

SyncPolicy kcenon::thread::policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy >::sync_policy_

private

Definition at line 370 of file policy_queue.h.

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

include/kcenon/thread/forward.h
include/kcenon/thread/interfaces/pool_queue_adapter.h
include/kcenon/thread/interfaces/queue_traits.h
include/kcenon/thread/policies/policy_queue.h

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Template Parameters

Design Pattern

Thread Safety

Usage Example

Policy Compatibility Matrix

Member Typedef Documentation

◆ bound_policy_type

◆ overflow_policy_type

◆ sync_policy_type

Constructor & Destructor Documentation

◆ policy_queue() [1/5]

◆ policy_queue() [2/5]

◆ policy_queue() [3/5]

◆ ~policy_queue()

◆ policy_queue() [4/5]

◆ policy_queue() [5/5]

Member Function Documentation

◆ bound_policy() [1/2]

◆ bound_policy() [2/2]

◆ clear()

◆ dequeue()

◆ empty()

◆ enqueue() [1/2]

◆ enqueue() [2/2]

◆ get_capabilities()

◆ get_next_job()

◆ handle_overflow()

◆ is_bounded()

◆ is_full()

◆ is_stopped()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ overflow_policy() [1/2]

◆ overflow_policy() [2/2]

◆ remaining_capacity()

◆ schedule()

◆ size()

◆ stop()

◆ sync_policy() [1/2]

◆ sync_policy() [2/2]

◆ try_dequeue()

Member Data Documentation

◆ bound_policy_

◆ overflow_policy_

◆ sync_policy_