mtcore::RingBuffer< T > Struct Template Reference

Represents a ring buffer with dynamically allocated memory Can be used as a FIFO or LIFO queue Allows memory reuse rather than continuous memory allocations as it is used May be dynamically resized. More...

#include <ring_buffer.hpp>

Public Types
using	Elem = T

Public Member Functions
decltype(auto)	ptr_iter () noexcept
	Gets iterator over pointers to elements.
decltype(auto)	ptr_iter () const noexcept
	Gets iterator over const pointers to elements.
decltype(auto)	iter () noexcept
	Gets iterator over values.
Result< void, AllocationError >	init (Allocator &alloc, size_t initCapacity=10) noexcept
	Initializes an empty ArrayList with an initial capacity.
Result< void, AllocationError >	init (Allocator &alloc, std::initializer_list< T > init, size_t capacity=0) noexcept
	Initializes an ring buffer with specified elements.
void	deinit (Allocator &alloc)
	Cleans up any memory held by ring buffer.
const T &	operator[] (size_t i) const noexcept
	Access element.
T &	operator[] (size_t i) noexcept
	Access element.
size_t	size () const noexcept
	Get size.
size_t	capacity () const noexcept
	Get capacity.
const T &	at (size_t i) const noexcept
	Access element.
T &	at (size_t i) noexcept
	Access element.
Result< void, AllocationError >	push_back (Allocator &alloc, const T &elem)
	Add element to back of buffer.
Result< void, AllocationError >	push_front (Allocator &alloc, const T &elem)
	Add element to front of buffer.
Result< void, CollectionAddNoAllocationError >	push_back (const T &elem)
	Add element to back of buffer.
Result< void, AllocationError >	shrink_to_fit (Allocator &alloc)
Result< void, CollectionAddNoAllocationError >	push_front (const T &elem)
	Add element to front of buffer.
Optional< T >	pop_front ()
	Removes and returns element from front.
Optional< T >	pop_back ()
	Removes and returns element from back.

Detailed Description

template<typename T>
struct mtcore::RingBuffer< T >

Represents a ring buffer with dynamically allocated memory Can be used as a FIFO or LIFO queue Allows memory reuse rather than continuous memory allocations as it is used May be dynamically resized.

Accessing elements is \(O(1)\) Adding elements is worst case \(O(N)\), but generally is \(O(1)\) Removing elements is \(O(1)\)

Template Parameters

T	Type of element stored

Definition at line 42 of file ring_buffer.hpp.

Member Typedef Documentation

Elem

template<typename T>

using mtcore::RingBuffer< T >::Elem = T

Definition at line 50 of file ring_buffer.hpp.

Member Function Documentation

at() [1/2]

template<typename T>

const T & mtcore::RingBuffer< T >::at ( size_t i ) const

inlinenodiscardnoexcept

Access element.

Definition at line 156 of file ring_buffer.hpp.

                                                       {
      ensure(elements.head, "NOT INITIALIZED");
      ensure(i < count, "OUT OF BOUNDS ACCESS");
      auto index = i + head;
      if (index >= elements.size()) {
        index -= elements.size();
      }
      return elements[index];
    }

Here is the caller graph for this function:

at() [2/2]

template<typename T>

T & mtcore::RingBuffer< T >::at ( size_t i )

inlinenoexcept

Access element.

Definition at line 167 of file ring_buffer.hpp.

                             {
      ensure(elements.head, "NOT INITIALIZED");
      ensure(i < count, "OUT OF BOUNDS ACCESS");
      auto index = i + head;
      if (index >= elements.size()) {
        index -= elements.size();
      }
      return elements[index];
    }

capacity()

template<typename T>

size_t mtcore::RingBuffer< T >::capacity ( ) const

inlinenodiscardnoexcept

Get capacity.

Definition at line 153 of file ring_buffer.hpp.

{ return elements.size(); }

Here is the caller graph for this function:

deinit()

template<typename T>

void mtcore::RingBuffer< T >::deinit ( Allocator & alloc )

inline

Cleans up any memory held by ring buffer.

Parameters

alloc

Allocator to use for cleanup

Definition at line 128 of file ring_buffer.hpp.

                                  {
      if (elements.head) {
        alloc.destroy_many(elements);
        elements.head = nullptr;
      }
      elements.len = 0;
      head         = 0;
      tail         = 0;
      count        = 0;
    }

Here is the call graph for this function:

init() [1/2]

template<typename T>

Result< void, AllocationError > mtcore::RingBuffer< T >::init ( Allocator & alloc, size_t initCapacity = 10 )

inlinenoexcept

Initializes an empty ArrayList with an initial capacity.

Parameters

alloc	Allocator to use for initial allocation
initCapacity	(Optional) Initial capacity to have (defaults to 10)

Returns

success or failure

Definition at line 83 of file ring_buffer.hpp.

                                                                                            {
      ensure(!head && !tail && !count, "ALREADY INITIALIZED");
      ensure(elements.head == nullptr && elements.size() == 0, "ALREADY INITIALIZED!");
      initCapacity  = initCapacity ? initCapacity : 10;
      auto allocRes = alloc.create_many<T>(initCapacity);
      if (allocRes.is_error()) {
        return allocRes.error();
      }
 
      elements = *allocRes;
      return success();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

init() [2/2]

template<typename T>

Result< void, AllocationError > mtcore::RingBuffer< T >::init ( Allocator & alloc, std::initializer_list< T > init, size_t capacity = 0 )

inlinenoexcept

Initializes an ring buffer with specified elements.

Parameters

alloc	Allocator to use for initial allocation
init	Initial value list
capacity	(Optional) initial capacity (if bigger than the initial value list)

Returns

success or failure

Definition at line 104 of file ring_buffer.hpp.

                                                                                                                    {
      ensure(!head && !tail && !count, "ALREADY INITIALIZED");
      ensure(elements.head == nullptr && elements.size() == 0, "ALREADY INITIALIZED!");
      if (capacity < init.size()) {
        capacity = init.size();
      }
      capacity      = capacity ? capacity : 10;
      auto allocRes = alloc.create_many<T>(init.size());
      if (allocRes.is_error()) {
        return allocRes.error();
      }
 
      elements = *allocRes;
      for (const auto &elem: init) {
        (void) push_back(elem);
      }
 
      return success();
    }

Here is the call graph for this function:

iter()

template<typename T>

decltype(auto) mtcore::RingBuffer< T >::iter ( )

inlinenoexcept

Gets iterator over values.

Returns

Iterator

Definition at line 72 of file ring_buffer.hpp.

                                   {
      ensure(elements.head, "NOT INITIALIZED");
      return iter::val(*this);
    }

Here is the call graph for this function:

operator[]() [1/2]

template<typename T>

const T & mtcore::RingBuffer< T >::operator[] ( size_t i ) const

inlinenoexcept

Access element.

Definition at line 140 of file ring_buffer.hpp.

                                                 {
      ensure(elements.head, "NOT INITIALIZED");
      return at(i);
    }

Here is the call graph for this function:

operator[]() [2/2]

template<typename T>

T & mtcore::RingBuffer< T >::operator[] ( size_t i )

inlinenoexcept

Access element.

Definition at line 145 of file ring_buffer.hpp.

                                     {
      ensure(elements.head, "NOT INITIALIZED");
      return at(i);
    }

Here is the call graph for this function:

pop_back()

template<typename T>

Optional< T > mtcore::RingBuffer< T >::pop_back ( )

inline

Removes and returns element from back.

Returns nullopt if empty

Definition at line 284 of file ring_buffer.hpp.

                           {
      ensure(elements.head, "NOT INITIALIZED");
      mtdefer { ensure(size() <= capacity(), "SIZE MISMATCH"); };
      if (count == 0) {
        return nullopt;
      }
 
      auto new_tail = tail;
      if (new_tail == 0) {
        new_tail = elements.size() - 1;
      }
      else {
        new_tail--;
      }
 
      auto res = elements[tail];
      --count;
      tail = new_tail;
      return res;
    }

Here is the call graph for this function:

pop_front()

template<typename T>

Optional< T > mtcore::RingBuffer< T >::pop_front ( )

inline

Removes and returns element from front.

Returns nullopt if empty

Definition at line 267 of file ring_buffer.hpp.

                            {
      ensure(elements.head, "NOT INITIALIZED");
      mtdefer { ensure(size() <= capacity(), "SIZE MISMATCH"); };
      if (count == 0) {
        return nullopt;
      }
 
      auto &res = elements[head++];
 
      count--;
      if (head == elements.size()) {
        head = 0;
      }
      return Optional{std::move(res)};
    }

Here is the call graph for this function:

ptr_iter() [1/2]

template<typename T>

decltype(auto) mtcore::RingBuffer< T >::ptr_iter ( ) const

inlinenoexcept

Gets iterator over const pointers to elements.

Returns

Iterator

Definition at line 64 of file ring_buffer.hpp.

                                             {
      ensure(elements.head, "NOT INITIALIZED");
      return iter::const_ptr(*this);
    }

Here is the call graph for this function:

ptr_iter() [2/2]

template<typename T>

decltype(auto) mtcore::RingBuffer< T >::ptr_iter ( )

inlinenoexcept

Gets iterator over pointers to elements.

Returns

Iterator

Definition at line 56 of file ring_buffer.hpp.

                                       {
      ensure(elements.head, "NOT INITIALIZED");
      return iter::ptr(*this);
    }

Here is the call graph for this function:

push_back() [1/2]

template<typename T>

Result< void, AllocationError > mtcore::RingBuffer< T >::push_back ( Allocator & alloc, const T & elem )

inline

Add element to back of buffer.

Allocate more memory if needed

Definition at line 178 of file ring_buffer.hpp.

                                                                             {
      ensure(elements.head, "NOT INITIALIZED");
      mtdefer { ensure(size() <= capacity(), "SIZE MISMATCH"); };
      if (auto err = grow_if_needed(alloc); err.is_error()) {
        return err;
      }
      if (push_back(elem).is_error()) {
        return error(AllocationError::ALLOCATION_FAILED);
      }
      return success();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

push_back() [2/2]

template<typename T>

Result< void, CollectionAddNoAllocationError > mtcore::RingBuffer< T >::push_back ( const T & elem )

inline

Add element to back of buffer.

Errors if full

Definition at line 204 of file ring_buffer.hpp.

                                                                          {
      ensure(elements.head, "NOT INITIALIZED");
      mtdefer { ensure(size() <= capacity(), "SIZE MISMATCH"); };
      if (count >= elements.size()) {
        return error(CollectionAddNoAllocationError::NO_ROOM);
      }
 
      elements[tail++] = elem;
      count++;
      if (tail == elements.size()) {
        tail = 0;
      }
      return success();
    }

Here is the call graph for this function:

push_front() [1/2]

template<typename T>

Result< void, AllocationError > mtcore::RingBuffer< T >::push_front ( Allocator & alloc, const T & elem )

inline

Add element to front of buffer.

Allocate more memory if needed

Definition at line 191 of file ring_buffer.hpp.

                                                                              {
      ensure(elements.head, "NOT INITIALIZED");
      mtdefer { ensure(size() <= capacity(), "SIZE MISMATCH"); };
      if (auto err = grow_if_needed(alloc); err.is_error()) {
        return err;
      }
      if (push_front(elem).is_error()) {
        return error(AllocationError::ALLOCATION_FAILED);
      }
      return success();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

push_front() [2/2]

template<typename T>

Result< void, CollectionAddNoAllocationError > mtcore::RingBuffer< T >::push_front ( const T & elem )

inline

Add element to front of buffer.

Errors if full

Definition at line 246 of file ring_buffer.hpp.

                                                                           {
      ensure(elements.head, "NOT INITIALIZED");
      mtdefer { ensure(size() <= capacity(), "SIZE MISMATCH"); };
      if (count >= elements.size()) {
        return error(CollectionAddNoAllocationError::NO_ROOM);
      }
 
      auto new_head = head;
      if (new_head == 0) {
        new_head = elements.size() - 1;
      }
      else {
        new_head--;
      }
      elements[new_head] = elem;
      count++;
      head = new_head;
      return success();
    }

Here is the call graph for this function:

shrink_to_fit()

template<typename T>

Result< void, AllocationError > mtcore::RingBuffer< T >::shrink_to_fit ( Allocator & alloc )

inline

Definition at line 219 of file ring_buffer.hpp.

                                                                  {
      const auto newSize = std::max(static_cast<size_t>(1), count);
      auto newBufferRes  = alloc.create_many<T>(newSize);
      if (newBufferRes.is_error()) {
        return newBufferRes.error();
      }
      auto newBuffer = *newBufferRes;
 
      for (size_t i = 0, curHead = head; i < newBuffer.size() && i < count; ++i) {
        mtdefer {
          curHead += 1;
          if (curHead == elements.size()) {
            curHead = 0;
          }
        };
        std::swap(newBuffer[i], elements[curHead]);
      }
      head  = 0;
      tail  = elements.size();
      count = tail - head;
      alloc.destroy_many(elements);
      elements = newBuffer;
      head     = 0;
      return success();
    }

Here is the call graph for this function:

size()

template<typename T>

size_t mtcore::RingBuffer< T >::size ( ) const

inlinenodiscardnoexcept

Get size.

Definition at line 151 of file ring_buffer.hpp.

{ return count; }

Here is the caller graph for this function:

---

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

• ring_buffer.hpp