This package provides ring buffer classes for use with C++17.

C++17 features are used if available, and backward compatibility is implemented up to C++14.

The purpose of a ring buffer is to provide a unidirectional FIFO communication from a thread to another. The implementation of this data structure can be lock-free, making it suitable for real-time programming.

I implement two variants of the ring buffer.

• Ring_Buffer is a bounded, lock-free ring buffer. The capacity is fixed and determined at instantiation. It can only store messages up to the capacity of the buffer.
• Soft_Ring_Buffer is an unbounded, mostly lock-free ring buffer. The storage expands as write operations require it, by a factor of 1.5. The access is protected by a shared-exclusive lock, and only blocks while the buffer expands. This object is adequate for soft real-time, when communicating all the messages is more important than missing a few deadlines.

Ring_Buffer(size_t capacity);

Instantiate the ring buffer with the given capacity.

size_t capacity() const;

Return the capacity.

size_t size_free() const;

Return the number of bytes available to write to.

template <class T> bool put(const T &x);

If the buffer has enough room (or the buffer is unbounded), store the sizeof(T) bytes of x, then return true. Otherwise, return false.

template <class T> bool put(const T *x, size_t n);

Similar to put above, except it stores an array of n consecutive T elements.

size_t size_used() const;

Return the number of bytes available to read.

bool discard(size_t len);

If the ringbuffer contains at least len bytes, extract them and ignore them, then return true. Otherwise, return false.

template <class T> bool get(T &x);

If the buffer contains enough data, extract sizeof(T) bytes and assign this data to x, then return true. Otherwise, return false.

template <class T> bool get(T *x, size_t n);

Similar to get above, except it extracts an array of n consecutive T elements.

template <class T> bool peek(T &x);

If the buffer contains enough data, extract sizeof(T) bytes without removing them from storage, assign this data to x, then return true. Otherwise, return false.

template <class T> bool peek(T *x, size_t n);

Similar to peek above, except it extracts an array of n consecutive T elements.