Ring buffer implementation, a.k.a circular buffer, exposing lock-free get*(..) and put*(..) methods. More...

#include <ringbuffer.hpp>

Inheritance diagram for jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >:

Collaboration diagram for jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >:

Public Types
typedef jau::callocator< Value_type >	allocator_type

typedef const value_type *	const_pointer

typedef const value_type &	const_reference

typedef std::make_signed< size_type >::type	difference_type

typedef value_type *	pointer

typedef value_type &	reference

typedef Size_type	size_type

typedef Value_type	value_type

Public Member Functions
	ringbuffer (const ringbuffer &_source) noexcept

	ringbuffer (const Size_type capacity) noexcept
	Create an empty ring buffer instance w/ the given net `capacity`. More...

	ringbuffer (const std::vector< Value_type > &copyFrom) noexcept
	Create a full ring buffer instance w/ the given array's net capacity and content. More...

	ringbuffer (const Value_type *copyFrom, const Size_type copyFromSize) noexcept

	ringbuffer (ringbuffer &&o) noexcept=default

	~ringbuffer () noexcept

Size_type	capacity () const noexcept
	Returns the net capacity of this ring buffer. More...

void	clear (const bool zeromem=false) noexcept
	Releasing all elements available, i.e. More...

void	close (const bool zeromem=false) noexcept
	Close this ringbuffer by releasing all elements available and resizing capacity to zero. More...

Size_type	drop (const Size_type max_count) noexcept
	Drops up to `max_count` oldest enqueued elements, but may drop less if not available. More...

bool	dropBlocking (const Size_type count, const fraction_i64 &timeout) noexcept
	Drops exactly `count` oldest enqueued elements, will block until they become available. More...

bool	dropBlocking (const Size_type count, const fraction_i64 &timeout, bool &timeout_occurred) noexcept
	Drops exactly `count` oldest enqueued elements, will block until they become available. More...

void	dump (FILE *stream, const std::string &prefix) const noexcept
	Debug functionality - Dumps the contents of the internal array. More...

Size_type	freeSlots () const noexcept
	Returns the number of free slots available to put. More...

bool	get (Value_type &result) noexcept
	Dequeues the oldest enqueued element, if available. More...

Size_type	get (Value_type *dest, const Size_type dest_len, const Size_type min_count) noexcept
	Dequeues the oldest enqueued `min(dest_len, size()>=min_count)` elements by copying them into the given consecutive 'dest' storage. More...

std::string	get_info () const noexcept

bool	getBlocking (Value_type &result, const fraction_i64 &timeout) noexcept
	Dequeues the oldest enqueued element. More...

bool	getBlocking (Value_type &result, const fraction_i64 &timeout, bool &timeout_occurred) noexcept
	Dequeues the oldest enqueued element. More...

Size_type	getBlocking (Value_type *dest, const Size_type dest_len, const Size_type min_count, const fraction_i64 &timeout) noexcept
	Dequeues the oldest enqueued `min(dest_len, size()>=min_count)` elements by copying them into the given consecutive 'dest' storage. More...

Size_type	getBlocking (Value_type *dest, const Size_type dest_len, const Size_type min_count, const fraction_i64 &timeout, bool &timeout_occurred) noexcept
	Dequeues the oldest enqueued `min(dest_len, size()>=min_count)` elements by copying them into the given consecutive 'dest' storage. More...

constexpr bool	getMultiPCEnabled () const
	Return whether multiple producer and consumer are enabled, see ringbuffer_multi_pc and ringbuffer_single_pc. More...

void	interruptReader () noexcept
	Interrupt a potentially blocked reader once. More...

void	interruptWriter () noexcept
	Interrupt a potentially blocked writer once. More...

bool	isEmpty () const noexcept
	Returns true if this ring buffer is empty, otherwise false. More...

bool	isFull () const noexcept
	Returns true if this ring buffer is full, otherwise false. More...

ringbuffer &	operator= (const ringbuffer &_source) noexcept

ringbuffer &	operator= (ringbuffer &&o) noexcept=default

bool	peek (Value_type &result) noexcept
	Peeks the next element at the read position w/o modifying pointer, nor blocking. More...

bool	peekBlocking (Value_type &result, const fraction_i64 &timeout) noexcept
	Peeks the next element at the read position w/o modifying pointer, but with blocking. More...

bool	peekBlocking (Value_type &result, const fraction_i64 &timeout, bool &timeout_occurred) noexcept
	Peeks the next element at the read position w/o modifying pointer, but with blocking. More...

bool	put (const Value_type &e) noexcept
	Enqueues the given element by copying it into this ringbuffer storage. More...

bool	put (const Value_type first, const Value_type last) noexcept
	Enqueues the given range of consecutive elements by copying it into this ringbuffer storage. More...

bool	put (Value_type &&e) noexcept
	Enqueues the given element by moving it into this ringbuffer storage. More...

bool	putBlocking (const Value_type &e, const fraction_i64 &timeout) noexcept
	Enqueues the given element by copying it into this ringbuffer storage. More...

bool	putBlocking (const Value_type &e, const fraction_i64 &timeout, bool &timeout_occurred) noexcept
	Enqueues the given element by copying it into this ringbuffer storage. More...

bool	putBlocking (const Value_type first, const Value_type last, const fraction_i64 &timeout) noexcept
	Enqueues the given range of consecutive elementa by copying it into this ringbuffer storage. More...

bool	putBlocking (const Value_type first, const Value_type last, const fraction_i64 &timeout, bool &timeout_occurred) noexcept
	Enqueues the given range of consecutive elementa by copying it into this ringbuffer storage. More...

bool	putBlocking (Value_type &&e, const fraction_i64 &timeout) noexcept
	Enqueues the given element by moving it into this ringbuffer storage. More...

bool	putBlocking (Value_type &&e, const fraction_i64 &timeout, bool &timeout_occurred) noexcept
	Enqueues the given element by moving it into this ringbuffer storage. More...

void	recapacity (const Size_type newCapacity)
	Resizes this ring buffer's capacity. More...

void	reset (const std::vector< Value_type > &copyFrom) noexcept
	Clears all elements and add all `copyFrom` elements thereafter, as if reconstructing this ringbuffer instance. More...

void	reset (const Value_type *copyFrom, const Size_type copyFromCount) noexcept
	Clears all elements and add all `copyFrom` elements thereafter, as if reconstructing this ringbuffer instance. More...

void	set_end_of_input (const bool v=true) noexcept
	Set `End of Input` from writer thread, unblocking all read-operations and a potentially currently blocked reader thread. More...

constexpr_non_literal_var void	setMultiPCEnabled (const bool v)
	Enable or disable capability to handle multiple producer and consumer, see ringbuffer_multi_pc and ringbuffer_single_pc. More...

Size_type	size () const noexcept
	Returns the number of elements in this ring buffer. More...

std::string	toString () const noexcept
	Returns a short string representation incl. More...

Size_type	waitForElements (const Size_type min_count, const fraction_i64 &timeout, bool &timeout_occured) noexcept
	Blocks until at least `count` elements have been put for subsequent get() and getBlocking(). More...

Size_type	waitForFreeSlots (const Size_type min_count, const fraction_i64 &timeout, bool &timeout_occured) noexcept
	Blocks until at least `count` free slots become available for subsequent put() and putBlocking(). More...

Static Public Attributes
static constexpr const bool	uses_memcpy = use_memcpy

static constexpr const bool	uses_memmove = use_memmove

static constexpr const bool	uses_secmem = use_secmem

Detailed Description

template<typename Value_type, typename Size_type, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>
class jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >

Ring buffer implementation, a.k.a circular buffer, exposing lock-free get*(..) and put*(..) methods.

This data structure is also supporting Concurrency.

Implementation utilizes the Always Keep One Slot Open, hence implementation maintains an internal array of capacity plus one!

Characteristics

Read position points to the last read element.
Write position points to the last written element.

Empty	writePos == readPos	size == 0
Full	writePos == readPos - 1	size == capacity

Empty [RW][][ ][ ][ ][ ][ ][ ] ; W==R
Avail [ ][ ][R][.][.][.][.][W] ; W > R
Avail [.][.][.][W][ ][ ][R][.] ; W <  R - 1
Full  [.][.][.][.][.][W][R][.] ; W==R-1

Thread Safety

Thread safety is guaranteed, considering the mode of operation as described below.

One producer-thread and one consumer-thread

Expects one producer-thread at a time and one consumer-thread at a time concurrently. Threads can be different or the same.

This is the default mode with the least std::mutex operations.

Only blocking producer put() and consumer get() waiting for free slots or available data will utilize lock and wait for the corresponding operation.
Otherwise implementation is lock-free and relies on SC-DRF via atomic memory barriers.

See setMultiPCEnabled().

Implementation is thread safe if:

put*(..) operations from one producer-thread at a time.
get*(..) operations from one consumer-thread at a time.
put*(..) producer and get*(..) consumer threads can be different or the same.

Multiple producer-threads and multiple consumer-threads

Expects multiple producer-threads and multiple consumer-threads concurrently. Threads can be different or the same.

This operation mode utilizes a specific multi-producer and -consumer lock, synchronizing put*(..) and get*(..) operations separately.

Use setMultiPCEnabled() to enable or disable multiple producer and consumer mode.

Implementation is thread safe if:

put*(..) operations concurrently from multiple threads.
get*(..) operations concurrently from multiple threads.
put*(..) producer and get*(..) consumer threads can be different or the same.

Interruption of Consumer and Producer

To allow an application to unblock a potentially blocked producer (writer) or consumer (reader) thread once, one can call interruptWriter() or interruptReader() respectively.

Marking End of Input Stream (EOS)

To allow an application to mark the end of input stream, i.e. the producer (write) has completed filling the ringbuffer, one can call set_end_of_input().

Calling set_end_of_input(true) will unblock all read-operations from this point onwards. A potentially currently blocked reader thread is also interrupted and hence unblocked.

Non-Type Template Parameter (NTTP) controlling Value_type memory

See darray_ntt_params.

use_memmove

use_memmove see darray_memmove.

use_memcpy

use_memcpy has more strict requirements than use_memmove, i.e. strictly relies on Value_type being std::is_trivially_copyable_v<Value_type>.

It allows to merely use memory operations w/o the need for constructor or destructor.

See Trivial destructor being key requirement to TriviallyCopyable.

‍A trivial destructor is a destructor that performs no action. Objects with trivial destructors don't require a delete-expression and may be disposed of by simply deallocating their storage. All data types compatible with the C language (POD types) are trivially destructible.`

use_secmem

use_secmem see darray_secmem.

See also: darray_ntt_params; jau::sc_atomic_critical

Examples: test_lfringbuffer11.cpp.

Definition at line 182 of file ringbuffer.hpp.

Member Typedef Documentation

◆ value_type

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef Value_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::value_type

Definition at line 190 of file ringbuffer.hpp.

◆ pointer

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef value_type* jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::pointer

Definition at line 191 of file ringbuffer.hpp.

◆ const_pointer

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef const value_type* jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::const_pointer

Definition at line 192 of file ringbuffer.hpp.

◆ reference

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef value_type& jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::reference

Definition at line 193 of file ringbuffer.hpp.

◆ const_reference

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef const value_type& jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::const_reference

Definition at line 194 of file ringbuffer.hpp.

◆ size_type

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::size_type

Definition at line 195 of file ringbuffer.hpp.

◆ difference_type

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef std::make_signed<size_type>::type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::difference_type

Definition at line 196 of file ringbuffer.hpp.

◆ allocator_type

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef jau::callocator<Value_type> jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::allocator_type

Definition at line 198 of file ringbuffer.hpp.

Constructor & Destructor Documentation

◆ ringbuffer() [1/5]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::ringbuffer ( const std::vector< Value_type > & copyFrom )

inlinenoexcept

Create a full ring buffer instance w/ the given array's net capacity and content.

Example for a 10 element Integer array:

 Integer[] source = new Integer[10];
 // fill source with content ..
 ringbuffer<Integer> rb = new ringbuffer<Integer>(source);

isFull() returns true on the newly created full ring buffer.

Implementation will allocate an internal array with size of array copyFrom plus one, and copy all elements from array copyFrom into the internal array.

Parameters

copyFrom mandatory source array determining ring buffer's net capacity() and initial content.

Exceptions

IllegalArgumentException if copyFrom is nullptr

Definition at line 1072 of file ringbuffer.hpp.

◆ ringbuffer() [2/5]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::ringbuffer	(	const Value_type *	copyFrom,
		const Size_type	copyFromSize
	)

inlinenoexcept

Parameters

copyFrom
copyFromSize

Definition at line 1084 of file ringbuffer.hpp.

◆ ringbuffer() [3/5]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::ringbuffer ( const Size_type capacity )

inlinenoexcept

Create an empty ring buffer instance w/ the given net capacity.

Example for a 10 element Integer array:

 ringbuffer<Integer> rb = new ringbuffer<Integer>(10, Integer[].class);

isEmpty() returns true on the newly created empty ring buffer.

Implementation will allocate an internal array of size capacity plus one.

Parameters

arrayType	the array type of the created empty internal array.
capacity	the initial net capacity of the ring buffer

Definition at line 1109 of file ringbuffer.hpp.

◆ ~ringbuffer()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::~ringbuffer ( )

inlinenoexcept

Definition at line 1116 of file ringbuffer.hpp.

◆ ringbuffer() [4/5]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::ringbuffer ( const ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem > & _source )

inlinenoexcept

Definition at line 1124 of file ringbuffer.hpp.

◆ ringbuffer() [5/5]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::ringbuffer ( ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem > && o )

defaultnoexcept

Member Function Documentation

◆ toString()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

std::string jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::toString ( ) const

inlinenoexcept

Returns a short string representation incl.

size/capacity and internal r/w index (impl. dependent).

Definition at line 1024 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ dump()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::dump	(	FILE *	stream,
		const std::string &	prefix
	)		const

inlinenoexcept

Debug functionality - Dumps the contents of the internal array.

Definition at line 1033 of file ringbuffer.hpp.

◆ get_info()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

std::string jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::get_info ( ) const

inlinenoexcept

Definition at line 1037 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ operator=() [1/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

ringbuffer & jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::operator= ( const ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem > & _source )

inlinenoexcept

Definition at line 1136 of file ringbuffer.hpp.

◆ operator=() [2/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

ringbuffer & jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::operator= ( ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem > && o )

defaultnoexcept

◆ getMultiPCEnabled()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::getMultiPCEnabled ( ) const

inlineconstexpr

Return whether multiple producer and consumer are enabled, see ringbuffer_multi_pc and ringbuffer_single_pc.

Defaults to false.

See also: ringbuffer_multi_pc; ringbuffer_single_pc; getMultiPCEnabled(); setMultiPCEnabled()

Definition at line 1172 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ setMultiPCEnabled()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr_non_literal_var void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::setMultiPCEnabled ( const bool v )

inline

Enable or disable capability to handle multiple producer and consumer, see ringbuffer_multi_pc and ringbuffer_single_pc.

Defaults to false.

See also: ringbuffer_multi_pc; ringbuffer_single_pc; getMultiPCEnabled(); setMultiPCEnabled()

Definition at line 1184 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ capacity()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::capacity ( ) const

inlinenoexcept

Returns the net capacity of this ring buffer.

Definition at line 1207 of file ringbuffer.hpp.

◆ freeSlots()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::freeSlots ( ) const

inlinenoexcept

Returns the number of free slots available to put.

Definition at line 1210 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ isEmpty()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::isEmpty ( ) const

inlinenoexcept

Returns true if this ring buffer is empty, otherwise false.

Definition at line 1213 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ isFull()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::isFull ( ) const

inlinenoexcept

Returns true if this ring buffer is full, otherwise false.

Definition at line 1216 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ size()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::size ( ) const

inlinenoexcept

Returns the number of elements in this ring buffer.

Definition at line 1219 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ waitForElements()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::waitForElements	(	const Size_type	min_count,
		const fraction_i64 &	timeout,
		bool &	timeout_occured
	)

inlinenoexcept

Blocks until at least count elements have been put for subsequent get() and getBlocking().

Parameters

min_count	minimum number of put slots
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: the number of put elements, available for get() and getBlocking()

Definition at line 1236 of file ringbuffer.hpp.

◆ waitForFreeSlots()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::waitForFreeSlots	(	const Size_type	min_count,
		const fraction_i64 &	timeout,
		bool &	timeout_occured
	)

inlinenoexcept

Blocks until at least count free slots become available for subsequent put() and putBlocking().

Parameters

min_count	minimum number of free slots
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: the number of free slots, available for put() and putBlocking()

Definition at line 1254 of file ringbuffer.hpp.

◆ clear()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::clear ( const bool zeromem = false )

inlinenoexcept

Releasing all elements available, i.e.

size() at the time of the call

It is the user's obligation to ensure thread safety when using ringbuffer_single_pc, as implementation can only synchronize on the blocked put() and get() std::mutex.

Assuming no concurrent put() operation, after the call:

isEmpty() will return true
size() shall return 0

Parameters

zeromem pass true to zero ringbuffer memory after releasing elements, otherwise non template type parameter use_secmem determines the behavior (default), see ringbuffer_ntt_params.

See also: ringbuffer_ntt_params

Definition at line 1276 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ close()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::close ( const bool zeromem = false )

inlinenoexcept

Close this ringbuffer by releasing all elements available and resizing capacity to zero.

Essentially causing all read and write operations to fail.

Potential writer and reader thread will be

notified, allowing them to be woken up
interrupted to abort the write and read operation

Subsequent write and read operations will fail and not block.

After the call:

isEmpty() will return true
size() shall return 0
capacity() shall return 0
freeSlots() shall return 0

Definition at line 1320 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ reset() [1/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::reset	(	const Value_type *	copyFrom,
		const Size_type	copyFromCount
	)

inlinenoexcept

Clears all elements and add all copyFrom elements thereafter, as if reconstructing this ringbuffer instance.

It is the user's obligation to ensure thread safety when using ringbuffer_single_pc, as implementation can only synchronize on the blocked put() and get() std::mutex.

Parameters

copyFrom Mandatory array w/ length capacity() to be copied into the internal array.

See also: getMultiPCEnabled(); setMultiPCEnabled(); ringbuffer_multi_pc; ringbuffer_single_pc

Definition at line 1360 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ reset() [2/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::reset ( const std::vector< Value_type > & copyFrom )

inlinenoexcept

Clears all elements and add all copyFrom elements thereafter, as if reconstructing this ringbuffer instance.

It is the user's obligation to ensure thread safety when using ringbuffer_single_pc, as implementation can only synchronize on the blocked put() and get() std::mutex.

Parameters

copyFrom

See also: getMultiPCEnabled(); setMultiPCEnabled(); ringbuffer_multi_pc; ringbuffer_single_pc

Definition at line 1391 of file ringbuffer.hpp.

◆ recapacity()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::recapacity ( const Size_type newCapacity )

inline

Resizes this ring buffer's capacity.

New capacity must be greater than current size.

It is the user's obligation to ensure thread safety when using ringbuffer_single_pc, as implementation can only synchronize on the blocked put() and get() std::mutex.

Parameters

newCapacity

See also: getMultiPCEnabled(); setMultiPCEnabled(); ringbuffer_multi_pc; ringbuffer_single_pc

Definition at line 1424 of file ringbuffer.hpp.

◆ interruptReader()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::interruptReader ( )

inlinenoexcept

Interrupt a potentially blocked reader once.

Call this method to unblock a potentially blocked reader thread once.

Definition at line 1446 of file ringbuffer.hpp.

◆ set_end_of_input()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::set_end_of_input ( const bool v = true )

inlinenoexcept

Set End of Input from writer thread, unblocking all read-operations and a potentially currently blocked reader thread.

Call this method with true after concluding writing input data will unblock all read-operations from this point onwards. A potentially currently blocked reader thread is also interrupted and hence unblocked.

Definition at line 1454 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ interruptWriter()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::interruptWriter ( )

inlinenoexcept

Interrupt a potentially blocked writer once.

Call this method to unblock a potentially blocked writer thread once.

Definition at line 1466 of file ringbuffer.hpp.

◆ peek()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::peek ( Value_type & result )

inlinenoexcept

Peeks the next element at the read position w/o modifying pointer, nor blocking.

Method is non blocking and returns immediately;.

Parameters

result storage for the resulting value if successful, otherwise unchanged.

Returns: true if successful, otherwise false.

Definition at line 1476 of file ringbuffer.hpp.

◆ peekBlocking() [1/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::peekBlocking	(	Value_type &	result,
		const fraction_i64 &	timeout,
		bool &	timeout_occurred
	)

inlinenoexcept

Peeks the next element at the read position w/o modifying pointer, but with blocking.

Parameters

result	storage for the resulting value if successful, otherwise unchanged.
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: true if successful, otherwise false.

Definition at line 1494 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ peekBlocking() [2/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::peekBlocking	(	Value_type &	result,
		const fraction_i64 &	timeout
	)

inlinenoexcept

Peeks the next element at the read position w/o modifying pointer, but with blocking.

Parameters

result	storage for the resulting value if successful, otherwise unchanged.
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely

Returns: true if successful, otherwise false.

Definition at line 1510 of file ringbuffer.hpp.

◆ get() [1/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::get ( Value_type & result )

inlinenoexcept

Dequeues the oldest enqueued element, if available.

The ring buffer slot will be released and its value moved to the caller's result storage, if successful.

Method is non blocking and returns immediately;.

Parameters

result storage for the resulting value if successful, otherwise unchanged.

Returns: true if successful, otherwise false.

Definition at line 1525 of file ringbuffer.hpp.

◆ getBlocking() [1/4]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::getBlocking	(	Value_type &	result,
		const fraction_i64 &	timeout,
		bool &	timeout_occurred
	)

inlinenoexcept

Dequeues the oldest enqueued element.

The ring buffer slot will be released and its value moved to the caller's result storage, if successful.

Parameters

result	storage for the resulting value if successful, otherwise unchanged.
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: true if successful, otherwise false.

Definition at line 1545 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ getBlocking() [2/4]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::getBlocking	(	Value_type &	result,
		const fraction_i64 &	timeout
	)

inlinenoexcept

Dequeues the oldest enqueued element.

The ring buffer slot will be released and its value moved to the caller's result storage, if successful.

Parameters

result	storage for the resulting value if successful, otherwise unchanged.
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely

Returns: true if successful, otherwise false.

Definition at line 1563 of file ringbuffer.hpp.

◆ get() [2/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::get	(	Value_type *	dest,
		const Size_type	dest_len,
		const Size_type	min_count
	)

inlinenoexcept

Dequeues the oldest enqueued min(dest_len, size()>=min_count) elements by copying them into the given consecutive 'dest' storage.

The ring buffer slots will be released and its value moved to the caller's dest storage, if successful.

Method is non blocking and returns immediately;.

Parameters

dest	pointer to first storage element of `dest_len` consecutive elements to store the values, if successful.
dest_len	number of consecutive elements in `dest`, hence maximum number of elements to return.
min_count	minimum number of consecutive elements to return.

Returns: actual number of elements returned

Definition at line 1580 of file ringbuffer.hpp.

◆ getBlocking() [3/4]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::getBlocking	(	Value_type *	dest,
		const Size_type	dest_len,
		const Size_type	min_count,
		const fraction_i64 &	timeout,
		bool &	timeout_occurred
	)

inlinenoexcept

Dequeues the oldest enqueued min(dest_len, size()>=min_count) elements by copying them into the given consecutive 'dest' storage.

The ring buffer slots will be released and its value moved to the caller's dest storage, if successful.

Parameters

dest	pointer to first storage element of `dest_len` consecutive elements to store the values, if successful.
dest_len	number of consecutive elements in `dest`, hence maximum number of elements to return.
min_count	minimum number of consecutive elements to return
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: actual number of elements returned

Definition at line 1602 of file ringbuffer.hpp.

◆ getBlocking() [4/4]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::getBlocking	(	Value_type *	dest,
		const Size_type	dest_len,
		const Size_type	min_count,
		const fraction_i64 &	timeout
	)

inlinenoexcept

Dequeues the oldest enqueued min(dest_len, size()>=min_count) elements by copying them into the given consecutive 'dest' storage.

The ring buffer slots will be released and its value moved to the caller's dest storage, if successful.

Parameters

dest	pointer to first storage element of `dest_len` consecutive elements to store the values, if successful.
dest_len	number of consecutive elements in `dest`, hence maximum number of elements to return.
min_count	minimum number of consecutive elements to return
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely

Returns: actual number of elements returned

Definition at line 1622 of file ringbuffer.hpp.

◆ drop()

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

Size_type jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::drop ( const Size_type max_count )

inlinenoexcept

Drops up to max_count oldest enqueued elements, but may drop less if not available.

Method is non blocking and returns immediately;.

Parameters

max_count maximum number of elements to drop from ringbuffer.

Returns: number of elements dropped

Definition at line 1636 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ dropBlocking() [1/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::dropBlocking	(	const Size_type	count,
		const fraction_i64 &	timeout,
		bool &	timeout_occurred
	)

inlinenoexcept

Drops exactly count oldest enqueued elements, will block until they become available.

In count elements are not available to drop even after blocking for timeoutMS, no element will be dropped.

Parameters

count	number of elements to drop from ringbuffer.
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: true if successful, otherwise false

Definition at line 1660 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ dropBlocking() [2/2]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::dropBlocking	(	const Size_type	count,
		const fraction_i64 &	timeout
	)

inlinenoexcept

Drops exactly count oldest enqueued elements, will block until they become available.

In count elements are not available to drop even after blocking for timeoutMS, no element will be dropped.

Parameters

count	number of elements to drop from ringbuffer.
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely

Returns: true if successful, otherwise false

Definition at line 1682 of file ringbuffer.hpp.

◆ put() [1/3]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::put ( Value_type && e )

inlinenoexcept

Enqueues the given element by moving it into this ringbuffer storage.

Returns true if successful, otherwise false in case buffer is full.

Method is non blocking and returns immediately;.

Parameters

e	value to be moved into this ringbuffer

Returns: true if successful, otherwise false

Definition at line 1697 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ putBlocking() [1/6]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::putBlocking	(	Value_type &&	e,
		const fraction_i64 &	timeout,
		bool &	timeout_occurred
	)

inlinenoexcept

Enqueues the given element by moving it into this ringbuffer storage.

Parameters

e	value to be moved into this ringbuffer
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: true if successful, otherwise false in case timeout occurred or otherwise.

Definition at line 1715 of file ringbuffer.hpp.

Here is the caller graph for this function:

◆ putBlocking() [2/6]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::putBlocking	(	Value_type &&	e,
		const fraction_i64 &	timeout
	)

inlinenoexcept

Enqueues the given element by moving it into this ringbuffer storage.

Parameters

e	value to be moved into this ringbuffer
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely

Returns: true if successful, otherwise false in case timeout occurred or otherwise.

Definition at line 1731 of file ringbuffer.hpp.

◆ put() [2/3]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::put ( const Value_type & e )

inlinenoexcept

Enqueues the given element by copying it into this ringbuffer storage.

Returns true if successful, otherwise false in case buffer is full.

Method is non blocking and returns immediately;.

Returns: true if successful, otherwise false

Definition at line 1745 of file ringbuffer.hpp.

◆ putBlocking() [3/6]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::putBlocking	(	const Value_type &	e,
		const fraction_i64 &	timeout,
		bool &	timeout_occurred
	)

inlinenoexcept

Enqueues the given element by copying it into this ringbuffer storage.

Parameters

timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: true if successful, otherwise false in case timeout occurred or otherwise.

Definition at line 1762 of file ringbuffer.hpp.

◆ putBlocking() [4/6]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::putBlocking	(	const Value_type &	e,
		const fraction_i64 &	timeout
	)

inlinenoexcept

Enqueues the given element by copying it into this ringbuffer storage.

Parameters

timeout maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely

Returns: true if successful, otherwise false in case timeout occurred or otherwise.

Definition at line 1777 of file ringbuffer.hpp.

◆ put() [3/3]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::put	(	const Value_type *	first,
		const Value_type *	last
	)

inlinenoexcept

Enqueues the given range of consecutive elements by copying it into this ringbuffer storage.

Returns true if successful, otherwise false in case buffer is full.

Method is non blocking and returns immediately;.

Parameters

first	pointer to first consecutive element to range of value_type [first, last)
last	pointer to last consecutive element to range of value_type [first, last)

Returns: true if successful, otherwise false

Definition at line 1793 of file ringbuffer.hpp.

◆ putBlocking() [5/6]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::putBlocking	(	const Value_type *	first,
		const Value_type *	last,
		const fraction_i64 &	timeout,
		bool &	timeout_occurred
	)

inlinenoexcept

Enqueues the given range of consecutive elementa by copying it into this ringbuffer storage.

Parameters

first	pointer to first consecutive element to range of value_type [first, last)
last	pointer to last consecutive element to range of value_type [first, last)
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely
timeout_occurred	result value set to true if a timeout has occurred

Returns: true if successful, otherwise false in case timeout occurred or otherwise.

Definition at line 1812 of file ringbuffer.hpp.

◆ putBlocking() [6/6]

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::putBlocking	(	const Value_type *	first,
		const Value_type *	last,
		const fraction_i64 &	timeout
	)

inlinenoexcept

Enqueues the given range of consecutive elementa by copying it into this ringbuffer storage.

Parameters

first	pointer to first consecutive element to range of value_type [first, last)
last	pointer to last consecutive element to range of value_type [first, last)
timeout	maximum duration in fractions of seconds to wait, where fractions_i64::zero waits infinitely

Returns: true if successful, otherwise false in case timeout occurred or otherwise.

Definition at line 1829 of file ringbuffer.hpp.

Member Data Documentation

◆ uses_memmove

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::uses_memmove = use_memmove

staticconstexpr

Definition at line 184 of file ringbuffer.hpp.

◆ uses_memcpy

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::uses_memcpy = use_memcpy

staticconstexpr

Definition at line 185 of file ringbuffer.hpp.

◆ uses_secmem

template<typename Value_type , typename Size_type , bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_memcpy = std::is_trivially_copyable_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const bool jau::ringbuffer< Value_type, Size_type, use_memmove, use_memcpy, use_secmem >::uses_secmem = use_secmem

staticconstexpr

Definition at line 186 of file ringbuffer.hpp.

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

include/jau/ringbuffer.hpp

Public Types

Public Member Functions

Static Public Attributes

Detailed Description

Characteristics

Thread Safety

One producer-thread and one consumer-thread

Multiple producer-threads and multiple consumer-threads

Interruption of Consumer and Producer

Marking End of Input Stream (EOS)

See also

Non-Type Template Parameter (NTTP) controlling Value_type memory

use_memmove

use_memcpy

use_secmem

Member Typedef Documentation

◆ value_type

◆ pointer

◆ const_pointer

◆ reference

◆ const_reference

◆ size_type

◆ difference_type

◆ allocator_type

Constructor & Destructor Documentation

◆ ringbuffer() [1/5]

◆ ringbuffer() [2/5]

◆ ringbuffer() [3/5]

◆ ~ringbuffer()

◆ ringbuffer() [4/5]

◆ ringbuffer() [5/5]

Member Function Documentation

◆ toString()

◆ dump()

◆ get_info()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ getMultiPCEnabled()

◆ setMultiPCEnabled()

◆ capacity()

◆ freeSlots()

◆ isEmpty()

◆ isFull()

◆ size()

◆ waitForElements()

◆ waitForFreeSlots()

◆ clear()

◆ close()

◆ reset() [1/2]

◆ reset() [2/2]

◆ recapacity()

◆ interruptReader()

◆ set_end_of_input()

◆ interruptWriter()

◆ peek()

◆ peekBlocking() [1/2]

◆ peekBlocking() [2/2]

◆ get() [1/2]

◆ getBlocking() [1/4]

◆ getBlocking() [2/4]

◆ get() [2/2]

◆ getBlocking() [3/4]

◆ getBlocking() [4/4]

◆ drop()

◆ dropBlocking() [1/2]

◆ dropBlocking() [2/2]

◆ put() [1/3]

◆ putBlocking() [1/6]

◆ putBlocking() [2/6]

◆ put() [2/3]

◆ putBlocking() [3/6]

◆ putBlocking() [4/6]

◆ put() [3/3]

◆ putBlocking() [5/6]

◆ putBlocking() [6/6]

Member Data Documentation

◆ uses_memmove

◆ uses_memcpy

◆ uses_secmem