flow::ConcurrentFlexQueue< T > Class Template Reference

A thread-safe concurrent queue with flexible push and pop operations. More...

#include <flow_concurrent_flex_queue.h>

Classes
struct	Node

Public Member Functions
	ConcurrentFlexQueue ()
	Constructs an empty queue.
	ConcurrentFlexQueue (const ConcurrentFlexQueue &)=delete
	ConcurrentFlexQueue (ConcurrentFlexQueue &&)=delete
ConcurrentFlexQueue &	operator= (const ConcurrentFlexQueue &)=delete
ConcurrentFlexQueue &	operator= (ConcurrentFlexQueue &&)=delete
bool	empty () const
	Checks if the queue is empty.
void	push (const T &value)
	Pushes a new element into the queue.
void	push (T &&value)
	Pushes a new element into the queue.
template<typename... Args>
void	emplace (Args &&... args)
	Constructs a new element in place at the end of the queue.
std::optional< T >	tryFront () const
	Attempts to retrieve the first element without removing it.
std::optional< T >	tryPop ()
	Attempts to pop and return the first element.
T	waitPop ()
	Waits until the queue is not empty, then pops and returns the first element.

Private Attributes
std::unique_ptr< Node >	head_
Node *	tail_
std::mutex	headMux_
std::mutex	tailMux_
std::condition_variable	blocked_

Detailed Description

template<typename T>
class flow::ConcurrentFlexQueue< T >

A thread-safe concurrent queue with flexible push and pop operations.

Definition at line 11 of file flow_concurrent_flex_queue.h.

Constructor & Destructor Documentation

ConcurrentFlexQueue() [1/3]

template<typename T>

flow::ConcurrentFlexQueue< T >::ConcurrentFlexQueue ( )

inline

Constructs an empty queue.

Definition at line 25 of file flow_concurrent_flex_queue.h.

      : head_(std::make_unique<Node>()), tail_(head_.get()) {
    }

References head_, and tail_.

Referenced by ConcurrentFlexQueue(), ConcurrentFlexQueue(), operator=(), and operator=().

ConcurrentFlexQueue() [2/3]

template<typename T>

flow::ConcurrentFlexQueue< T >::ConcurrentFlexQueue ( const ConcurrentFlexQueue< T > & )

delete

References ConcurrentFlexQueue().

ConcurrentFlexQueue() [3/3]

template<typename T>

flow::ConcurrentFlexQueue< T >::ConcurrentFlexQueue ( ConcurrentFlexQueue< T > && )

delete

References ConcurrentFlexQueue().

Member Function Documentation

emplace()

template<typename T>

template<typename... Args>

void flow::ConcurrentFlexQueue< T >::emplace ( Args &&... args )

inline

Constructs a new element in place at the end of the queue.

Parameters

args	Arguments forwarded to construct the new element.

Definition at line 70 of file flow_concurrent_flex_queue.h.

                                 {
      auto dummy = std::make_unique<Node>();
      {
        std::lock_guard lock(tailMux_);
        tail_->value.emplace(std::forward<Args>(args)...);
        tail_->next = std::move(dummy);
        tail_ = tail_->next.get();
      }
      blocked_.notify_one();
    }

References blocked_, tail_, and tailMux_.

empty()

template<typename T>

bool flow::ConcurrentFlexQueue< T >::empty ( ) const

inline

Checks if the queue is empty.

Returns

True if the queue is empty, false otherwise.

Definition at line 36 of file flow_concurrent_flex_queue.h.

                       {
      std::scoped_lock lock(headMux_, tailMux_);
      return head_.get() == tail_;
    }

References head_, headMux_, tail_, and tailMux_.

operator=() [1/2]

template<typename T>

ConcurrentFlexQueue & flow::ConcurrentFlexQueue< T >::operator= ( ConcurrentFlexQueue< T > && )

delete

References ConcurrentFlexQueue().

operator=() [2/2]

template<typename T>

ConcurrentFlexQueue & flow::ConcurrentFlexQueue< T >::operator= ( const ConcurrentFlexQueue< T > & )

delete

References ConcurrentFlexQueue().

push() [1/2]

template<typename T>

void flow::ConcurrentFlexQueue< T >::push ( const T & value )

inline

Pushes a new element into the queue.

Parameters

value

The element to add.

Definition at line 43 of file flow_concurrent_flex_queue.h.

                              {
      auto dummy = std::make_unique<Node>();
      {
        std::lock_guard lock(tailMux_);
        tail_->value = value;
        tail_->next = std::move(dummy);
        tail_ = tail_->next.get();
      }
      blocked_.notify_one();
    }

References blocked_, tail_, and tailMux_.

push() [2/2]

template<typename T>

void flow::ConcurrentFlexQueue< T >::push ( T && value )

inline

Pushes a new element into the queue.

Parameters

value

The element to add.

Definition at line 56 of file flow_concurrent_flex_queue.h.

                         {
      auto dummy = std::make_unique<Node>();
      {
        std::lock_guard lock(tailMux_);
        tail_->value = std::move(value);
        tail_->next = std::move(dummy);
        tail_ = tail_->next.get();
      }
      blocked_.notify_one();
    }

References blocked_, tail_, and tailMux_.

tryFront()

template<typename T>

std::optional< T > flow::ConcurrentFlexQueue< T >::tryFront ( ) const

inline

Attempts to retrieve the first element without removing it.

Returns

A copy of the first element if the queue is not empty, std::nullopt otherwise.

Definition at line 83 of file flow_concurrent_flex_queue.h.

                                    {
      std::unique_lock lock(headMux_);
      if (head_.get() == tail_) {
        return std::nullopt;
      }
      return head_->value;
    }

References head_, headMux_, and tail_.

tryPop()

template<typename T>

std::optional< T > flow::ConcurrentFlexQueue< T >::tryPop ( )

inline

Attempts to pop and return the first element.

Returns

The first element moved if queue is not empty, std::nullopt otherwise.

Definition at line 93 of file flow_concurrent_flex_queue.h.

                            {
      std::unique_lock lock(headMux_);
      if (head_.get() == tail_) {
        return std::nullopt;
      }
 
      auto oldHead = std::move(head_);
      head_ = std::move(oldHead->next);
      return std::move(oldHead->value);
    }

References head_, headMux_, and tail_.

waitPop()

template<typename T>

T flow::ConcurrentFlexQueue< T >::waitPop ( )

inline

Waits until the queue is not empty, then pops and returns the first element.

Returns

The first element.

Definition at line 106 of file flow_concurrent_flex_queue.h.

                {
      std::unique_lock lock(headMux_);
      blocked_.wait(lock, [&]() { return head_.get() != tail_; });
 
      auto oldHead = std::move(head_);
      head_ = std::move(oldHead->next);
      return oldHead->value.value();
    }

References blocked_, head_, headMux_, and tail_.

Member Data Documentation

blocked_

template<typename T>

std::condition_variable flow::ConcurrentFlexQueue< T >::blocked_

private

Definition at line 21 of file flow_concurrent_flex_queue.h.

Referenced by emplace(), push(), push(), and waitPop().

head_

template<typename T>

std::unique_ptr<Node> flow::ConcurrentFlexQueue< T >::head_

private

Definition at line 17 of file flow_concurrent_flex_queue.h.

Referenced by ConcurrentFlexQueue(), empty(), tryFront(), tryPop(), and waitPop().

headMux_

template<typename T>

std::mutex flow::ConcurrentFlexQueue< T >::headMux_

mutableprivate

Definition at line 19 of file flow_concurrent_flex_queue.h.

Referenced by empty(), tryFront(), tryPop(), and waitPop().

tail_

template<typename T>

Node* flow::ConcurrentFlexQueue< T >::tail_

private

Definition at line 18 of file flow_concurrent_flex_queue.h.

Referenced by ConcurrentFlexQueue(), emplace(), empty(), push(), push(), tryFront(), tryPop(), and waitPop().

tailMux_

template<typename T>

std::mutex flow::ConcurrentFlexQueue< T >::tailMux_

mutableprivate

Definition at line 20 of file flow_concurrent_flex_queue.h.

Referenced by emplace(), empty(), push(), and push().

---

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

• flow_concurrent_flex_queue.h