uvco::BoundedQueue< T > Class Template Reference

#include <bounded_queue.h>

Public Member Functions
	BoundedQueue (unsigned capacity)
template<typename U > requires std::convertible_to<U, T>
void	put (U &&elem)
	Push an item to the queue.
T	get ()
	Pop an item from the queue.
unsigned	size () const
	Current number of contained items.
unsigned	capacity () const
	Maximum number of contained items.
bool	empty () const
	size() == 0
bool	hasSpace () const
	size() < capacity()

Private Attributes
std::vector< T >	queue_ {}
unsigned	head_ = 0
unsigned	tail_ = 0
unsigned	size_ = 0

Detailed Description

template<typename T>
class uvco::BoundedQueue< T >

A bounded FIFO queue based on a contiguous array.

Warning: only for internal use. The push()/pop() interface is not safe in Release mode binaries; BoundedQueue is only intended to be used as part of Channel<T>.

Constructor & Destructor Documentation

BoundedQueue()

template<typename T >

uvco::BoundedQueue< T >::BoundedQueue ( unsigned  capacity )

inlineexplicit

{ queue_.reserve(capacity); }

Member Function Documentation

capacity()

template<typename T >

unsigned uvco::BoundedQueue< T >::capacity ( ) const

inline

Maximum number of contained items.

{ return queue_.capacity(); }

empty()

template<typename T >

bool uvco::BoundedQueue< T >::empty ( ) const

inline

size() == 0

{ return size() == 0; }

get()

template<typename T >

T uvco::BoundedQueue< T >::get ( )

inline

Pop an item from the queue.

          {
    if (empty()) [[unlikely]] {
      throw UvcoException(UV_EAGAIN, "queue is empty");
    }
    T element = std::move(queue_.at(tail_++));
    tail_ = tail_ % capacity();
    --size_;
    return element;
  }

hasSpace()

template<typename T >

bool uvco::BoundedQueue< T >::hasSpace ( ) const

inline

size() < capacity()

{ return size() < capacity(); }

put()

template<typename T >

template<typename U >
requires std::convertible_to<U, T>

void uvco::BoundedQueue< T >::put ( U &&  elem )

inline

Push an item to the queue.

  {
    if (!hasSpace()) {
      throw UvcoException(UV_EBUSY, "queue is full");
    }
    if (queue_.size() < capacity()) {
      BOOST_ASSERT(tail_ <= head_);
      queue_.push_back(std::forward<U>(elem));
    } else {
      queue_.at(head_) = std::forward<U>(elem);
    }
    head_ = (head_ + 1) % capacity();
    ++size_;
  }

size()

template<typename T >

unsigned uvco::BoundedQueue< T >::size ( ) const

inline

Current number of contained items.

{ return size_; }

Member Data Documentation

head_

template<typename T >

unsigned uvco::BoundedQueue< T >::head_ = 0

private

queue_

template<typename T >

std::vector<T> uvco::BoundedQueue< T >::queue_ {}

private

{};

size_

template<typename T >

unsigned uvco::BoundedQueue< T >::size_ = 0

private

tail_

template<typename T >

unsigned uvco::BoundedQueue< T >::tail_ = 0

private

---

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

• uvco/bounded_queue.h