Provides a straightforward thread-safe double-ended queue implementation. More...

#include <ThreadSafeQueue.hpp>

Public Member Functions
void	produce (ValueT value)
	Enqueue a value.
std::optional< ValueT >	try_consume ()
	Attempt to dequeue a value.
std::optional< ValueT >	wait_consume (std::stop_token stop_token)
	Attempt to dequeue a value.
bool	empty () const
	Checks the state of the queue.
void	clear ()
	Empties the queue.

Private Attributes
std::mutex	mutex
std::condition_variable_any	cv
std::deque< ValueT >	queue

Detailed Description

template<class ValueT>
requires std::move_constructible<ValueT>
class echomap::ThreadSafeQueue< ValueT >

Provides a straightforward thread-safe double-ended queue implementation.

Values of the templated type may be enqueued ("produced") and dequeued ("consumed") in a blocking or non-blocking (but interruptable) model. All operations are atomic.

Template Parameters

ValueT The type of values to be queued.

Definition at line 29 of file ThreadSafeQueue.hpp.

Member Function Documentation

◆ clear()

template<class ValueT>

void echomap::ThreadSafeQueue< ValueT >::clear ( )

inline

Empties the queue.

Definition at line 106 of file ThreadSafeQueue.hpp.

    {
        std::scoped_lock lock(mutex);
        queue.clear();
    }

◆ empty()

template<class ValueT>

bool echomap::ThreadSafeQueue< ValueT >::empty ( ) const

inlinenodiscard

Checks the state of the queue.

Returns: Is the queue empty?

Definition at line 97 of file ThreadSafeQueue.hpp.

    {
        std::scoped_lock lock(mutex);
        return queue.empty();
    }

◆ produce()

template<class ValueT>

void echomap::ThreadSafeQueue< ValueT >::produce ( ValueT value )

inline

Enqueue a value.

Parameters

value The value to enqueue.

Definition at line 37 of file ThreadSafeQueue.hpp.

    {
        std::scoped_lock lock(mutex);
        queue.push_back(std::move(value));
        cv.notify_one();
    }

◆ try_consume()

template<class ValueT>

std::optional< ValueT > echomap::ThreadSafeQueue< ValueT >::try_consume ( )

inline

Attempt to dequeue a value.

This function does not block.

Returns: The dequeued value, or the empty optional if there were no results available.

Definition at line 53 of file ThreadSafeQueue.hpp.

    {
        std::scoped_lock lock(mutex);
 
        if (!queue.empty()) {
            auto value = std::move(queue.front());
            queue.pop_front();
            return value;
        }
 
        return std::nullopt;
    }

◆ wait_consume()

template<class ValueT>

std::optional< ValueT > echomap::ThreadSafeQueue< ValueT >::wait_consume ( std::stop_token stop_token )

inline

Attempt to dequeue a value.

This function blocks until interrupted by the stop token or a value is available on the queue.

Parameters

stop_token The interrupt token for the thread block.

Returns: The dequeued value, or an empty optional if the block was interrupted prior to a value becoming available.

Definition at line 75 of file ThreadSafeQueue.hpp.

    {
        std::unique_lock lock(mutex);
        cv.wait(lock, stop_token, [this] {
            return !queue.empty();
        });
 
        if (queue.empty())
            return std::nullopt;
 
        auto value = std::move(queue.front());
        queue.pop_front();
        return value;
    }