uvco::BoundedQueue< T > Class Template Reference

#include <bounded_queue.h>

Public Member Functions
	BoundedQueue (size_t 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()
void	forEach (std::function< void(T &)> function)

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 put()/get() 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 ( size_t capacity )

inlineexplicit

{ queue_.reserve(capacity); }

Member Function Documentation

capacity()

template<typename T>

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

inlinenodiscard

Maximum number of contained items.

{ return queue_.capacity(); }

empty()

template<typename T>

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

inlinenodiscard

size() == 0

{ return size() == 0; }

forEach()

template<typename T>

void uvco::BoundedQueue< T >::forEach

(

std::function< void(T &)>

function

)

                                                             {
  unsigned idx = tail_;
  for (unsigned i = 0; i < size_; ++i) {
    function(queue_.at(idx));
    idx = (idx + 1) % capacity();
  }
}

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

inlinenodiscard

size() < capacity()

{ return size() < capacity(); }

put()

template<typename T>
requires std::convertible_to<U, 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

inlinenodiscard

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