MooseUtils::CircularBuffer< T > Class Template Reference

An optimized circular buffer. More...

#include <CircularBuffer.h>

Inheritance diagram for MooseUtils::CircularBuffer< T >:

Public Types
typedef std::vector< T >::iterator	iterator
typedef std::vector< T >::const_iterator	const_iterator

Public Member Functions
	CircularBuffer ()
	CircularBuffer (const std::size_t capacity)
virtual void	erase (const std::size_t num) override
	Remove the first num elements. More...
virtual void	eraseChunk (const std::size_t chunk_size) override
virtual Buffer< T >::iterator	beginChunk (const std::size_t chunk_size) override
	Iterator for the first entry with a given chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given. More...
virtual Buffer< T >::const_iterator	beginChunk (const std::size_t chunk_size) const override
	Const iterator for the first entry with a given chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given. More...
virtual Buffer< T >::iterator	endChunk (const std::size_t chunk_size) override
	Iterator for the last entry of a chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given. More...
virtual Buffer< T >::const_iterator	endChunk (const std::size_t chunk_size) const override
	Const iterator for the last entry of a chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given. More...
void	setCapacity (const std::size_t capacity)
	Resize the capacity. More...
std::size_t	capacity () const
	Get the capacity. More...
void	setSize (const std::size_t size)
	Set the size. More...
std::size_t	size () const
	Get the size. More...
bool	empty () const
	Whether or not the buffer is empty. More...
void	push_back (const T &value)
	Add a new entry on the end. More...
void	move (T &value)
	Moves the object into the buffer (calls std::move()) More...
void	append (const_iterator in_begin, const_iterator in_end)
	Add new entries to the end. More...
void	append (const std::vector< T > &vals)
	Add new entries to the end. More...
void	clear ()
	Remove all entries (does not change the capacity) Note: this does NOT at all free any entries. More...
iterator	begin ()
	Iterator for the first entry in the buffer. More...
const_iterator	begin () const
	Const iterator for the first entry in the buffer. More...
iterator	end ()
	Iterator for the last entry in the buffer. More...
const_iterator	end () const
	Const iterator for the last entry in the buffer. More...
T &	operator[] (const std::size_t index)
	Access an entry at index. More...
const T &	operator[] (const std::size_t index) const
	Const access an entry at an index. More...
void	swap (std::vector< T > &in_data)
	Use in_data as our data vector. More...
const std::vector< T > &	data ()
	Access the raw underlying storage. More...
std::size_t	dataBeginPos () const
	The current beginning position of the buffer in data(). More...
std::size_t	dataEndPos () const
	The current end position of the buffer in data(). More...

Protected Member Functions
virtual std::size_t	newEnd (const std::size_t new_end) override
	Find out where the new end will be. More...

Protected Attributes
std::vector< T >	_data
	The raw data. More...
std::size_t	_begin_pos
	The beginning position. More...
std::size_t	_end_pos
	The ending position. More...

Detailed Description

template<typename T>
class MooseUtils::CircularBuffer< T >

An optimized circular buffer.

This also always ensures that begin() < end(). That means that if the end of the buffer capacity is reached, an O(N) operation will be used to move data from the end of the capacity to the beginning

This is done so that begin()/end() iterators can be used in OpenMP loops Also means that operator[] works sequentially between 0 and size()

It will also automatically grow larger if capacity is reached

NOTE: This buffer will not properly wrap around as a standard circular buffer does. Once the end of the internal storage has been reached, the data will be moved to the beginning of the internal storage via a copy. This is needed to ensure that the access through the begin()/end() iterators is contiguous.

Definition at line 36 of file CircularBuffer.h.

Member Typedef Documentation

const_iterator

template<typename T>

typedef std::vector<T>::const_iterator MooseUtils::Buffer< T >::const_iterator

inherited

Definition at line 32 of file Buffer.h.

iterator

template<typename T>

typedef std::vector<T>::iterator MooseUtils::Buffer< T >::iterator

inherited

Definition at line 31 of file Buffer.h.

Constructor & Destructor Documentation

CircularBuffer() [1/2]

template<typename T >

MooseUtils::CircularBuffer< T >::CircularBuffer

(

)

Definition at line 57 of file CircularBuffer.h.

                                  : Buffer<T>()
{
}

CircularBuffer() [2/2]

template<typename T >

MooseUtils::CircularBuffer< T >::CircularBuffer

(

const std::size_t

capacity

)

Definition at line 62 of file CircularBuffer.h.

                                                          : Buffer<T>(capacity)
{
}

Member Function Documentation

append() [1/2]

template<typename T >

void MooseUtils::Buffer< T >::append ( const_iterator  in_begin, const_iterator  in_end  )

inherited

Add new entries to the end.

Everything in [in_begin, in_end) is appended

Definition at line 241 of file Buffer.h.

{
  const auto additional_size = std::distance(in_begin, in_end);
  if (additional_size == 0)
    return;

  this->_end_pos = this->newEnd(this->_end_pos + additional_size);
  std::copy(in_begin, in_end, this->end() - additional_size);
}

append() [2/2]

template<typename T >

void MooseUtils::Buffer< T >::append ( const std::vector< T > &  vals )

inherited

Add new entries to the end.

Definition at line 253 of file Buffer.h.

{
  this->append(vals.begin(), vals.end());
}

begin() [1/2]

template<typename T>

iterator MooseUtils::Buffer< T >::begin ( )

inlineinherited

Iterator for the first entry in the buffer.

Definition at line 113 of file Buffer.h.

{ return this->_data.begin() + this->_begin_pos; }

begin() [2/2]

template<typename T>

const_iterator MooseUtils::Buffer< T >::begin ( ) const

inlineinherited

Const iterator for the first entry in the buffer.

Definition at line 117 of file Buffer.h.

{ return this->_data.begin() + this->_begin_pos; }

beginChunk() [1/2]

template<typename T >

Buffer< T >::iterator MooseUtils::CircularBuffer< T >::beginChunk ( const std::size_t  chunk_size )

overridevirtual

Iterator for the first entry with a given chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given.

Implements MooseUtils::Buffer< T >.

Definition at line 91 of file CircularBuffer.h.

{
  return this->begin();
}

beginChunk() [2/2]

template<typename T >

Buffer< T >::const_iterator MooseUtils::CircularBuffer< T >::beginChunk ( const std::size_t  chunk_size ) const

overridevirtual

Const iterator for the first entry with a given chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given.

Implements MooseUtils::Buffer< T >.

Definition at line 98 of file CircularBuffer.h.

{
  return this->begin();
}

capacity()

template<typename T>

std::size_t MooseUtils::Buffer< T >::capacity ( ) const

inlineinherited

Get the capacity.

Definition at line 53 of file Buffer.h.

{ return this->_data.size(); }

clear()

template<typename T >

void MooseUtils::Buffer< T >::clear ( )

inherited

Remove all entries (does not change the capacity) Note: this does NOT at all free any entries.

Definition at line 260 of file Buffer.h.

{
  this->_begin_pos = 0;
  this->_end_pos = 0;
}

data()

template<typename T>

const std::vector<T>& MooseUtils::Buffer< T >::data ( )

inlineinherited

Access the raw underlying storage.

This is considered an advanced interface. Typically, you should use the begin(), beginChunk(), end(), and endChunk() methods for accessing the data. This should really only be used in unit tests for verifying the underlying storage.

Definition at line 172 of file Buffer.h.

{ return _data; }

dataBeginPos()

template<typename T>

std::size_t MooseUtils::Buffer< T >::dataBeginPos ( ) const

inlineinherited

The current beginning position of the buffer in data().

This is considered an advanced interface because data() is the internal storage for the buffer. It should really only be used in unit tests for verifying the underlying storage.

Definition at line 182 of file Buffer.h.

{ return _begin_pos; }

dataEndPos()

template<typename T>

std::size_t MooseUtils::Buffer< T >::dataEndPos ( ) const

inlineinherited

The current end position of the buffer in data().

This is considered an advanced interface because data() is the internal storage for the buffer. It should really only be used in unit tests for verifying the underlying storage.

Definition at line 192 of file Buffer.h.

{ return _end_pos; }

empty()

template<typename T>

bool MooseUtils::Buffer< T >::empty ( ) const

inlineinherited

Whether or not the buffer is empty.

Definition at line 67 of file Buffer.h.

{ return !size(); }

end() [1/2]

template<typename T>

iterator MooseUtils::Buffer< T >::end ( )

inlineinherited

Iterator for the last entry in the buffer.

Definition at line 122 of file Buffer.h.

{ return this->_data.begin() + this->_end_pos; }

end() [2/2]

template<typename T>

const_iterator MooseUtils::Buffer< T >::end ( ) const

inlineinherited

Const iterator for the last entry in the buffer.

Definition at line 126 of file Buffer.h.

{ return this->_data.begin() + this->_end_pos; }

endChunk() [1/2]

template<typename T >

Buffer< T >::iterator MooseUtils::CircularBuffer< T >::endChunk ( const std::size_t  chunk_size )

overridevirtual

Iterator for the last entry of a chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given.

Implements MooseUtils::Buffer< T >.

Definition at line 105 of file CircularBuffer.h.

{
  if (chunk_size > this->size())
    return this->end();
  else
    return this->begin() + chunk_size;
}

endChunk() [2/2]

template<typename T >

Buffer< T >::const_iterator MooseUtils::CircularBuffer< T >::endChunk ( const std::size_t  chunk_size ) const

overridevirtual

Const iterator for the last entry of a chunk size in the buffer If chunk_size is greater than the size of the buffer, the full range will be given.

Implements MooseUtils::Buffer< T >.

Definition at line 115 of file CircularBuffer.h.

{
  if (chunk_size > this->size())
    return this->end();
  else
    return this->begin() + chunk_size;
}

erase()

template<typename T >

void MooseUtils::CircularBuffer< T >::erase ( const std::size_t  num )

overridevirtual

Remove the first num elements.

Note that erased items are not guaranteed to be freed immediately

Implements MooseUtils::Buffer< T >.

Definition at line 68 of file CircularBuffer.h.

{
  mooseAssert(num <= this->size(), "Cannot erase past the last entry");

  this->_begin_pos += num;

  // If there's nothing in the buffer - let's reset the positions
  if (this->_begin_pos == this->_end_pos)
    this->clear();
}

eraseChunk()

template<typename T >

void MooseUtils::CircularBuffer< T >::eraseChunk ( const std::size_t  chunk_size )

overridevirtual

Implements MooseUtils::Buffer< T >.

Definition at line 81 of file CircularBuffer.h.

{
  if (chunk_size > this->size())
    this->erase(this->size());
  else
    this->erase(chunk_size);
}

move()

template<typename T >

void MooseUtils::Buffer< T >::move ( T &  value )

inherited

Moves the object into the buffer (calls std::move())

Definition at line 233 of file Buffer.h.

{
  this->_end_pos = newEnd(this->_end_pos + 1);
  this->_data[this->_end_pos - 1] = std::move(value);
}

newEnd()

template<typename T >

std::size_t MooseUtils::CircularBuffer< T >::newEnd ( const std::size_t  new_end )

overrideprotectedvirtual

Find out where the new end will be.

This will resize/copy data as necessary

Parameters

new_end

the proposed new_end position

Returns

The actual position of the new ending

Implements MooseUtils::Buffer< T >.

Definition at line 125 of file CircularBuffer.h.

{
  auto actual_new_end = new_end;

  if (new_end > this->_data.size())
  {
    const auto new_size = new_end - this->_begin_pos;

    // See if we need to grow our capacity
    if (this->_begin_pos == 0) // If we're already using the beginning - just resize
      this->_data.resize(2 * new_size);
    else
    {
      // Move everything to the beginning
      auto to_it = this->_data.begin();
      for (auto from_it = this->begin(); from_it < this->end(); ++from_it)
        *to_it++ = std::move(*from_it);

      this->_begin_pos = 0;
      actual_new_end = new_size;

      // If there still isn't room... add space
      if (actual_new_end > this->_data.size())
        this->_data.resize(2 * new_size);
    }
  }

  return actual_new_end;
}

operator[]() [1/2]

template<typename T >

T & MooseUtils::Buffer< T >::operator[] ( const std::size_t  index )

inherited

Access an entry at index.

Definition at line 268 of file Buffer.h.

{
  mooseAssert(this->_begin_pos + index < this->_end_pos, "Attempt to access off end of Buffer!");
  return this->_data[this->_begin_pos + index];
}

operator[]() [2/2]

template<typename T >

const T & MooseUtils::Buffer< T >::operator[] ( const std::size_t  index ) const

inherited

Const access an entry at an index.

Definition at line 276 of file Buffer.h.

{
  mooseAssert(this->_begin_pos + index < this->_end_pos, "Attempt to access off end of Buffer!");
  return this->_data[this->_begin_pos + index];
}

push_back()

template<typename T >

void MooseUtils::Buffer< T >::push_back ( const T &  value )

inherited

Add a new entry on the end.

Definition at line 225 of file Buffer.h.

{
  this->_end_pos = newEnd(this->_end_pos + 1);
  this->_data[this->_end_pos - 1] = value;
}

setCapacity()

template<typename T>

void MooseUtils::Buffer< T >::setCapacity ( const std::size_t  capacity )

inlineinherited

Resize the capacity.

Definition at line 49 of file Buffer.h.

{ this->_data.resize(capacity); }

setSize()

template<typename T>

void MooseUtils::Buffer< T >::setSize ( const std::size_t  size )

inlineinherited

Set the size.

Definition at line 58 of file Buffer.h.

{ this->_end_pos = this->newEnd(this->_begin_pos + size); }

size()

template<typename T>

std::size_t MooseUtils::Buffer< T >::size ( ) const

inlineinherited

Get the size.

Definition at line 62 of file Buffer.h.

Referenced by MooseUtils::Buffer< T >::empty().

{ return this->_end_pos - this->_begin_pos; }

swap()

template<typename T >

void MooseUtils::Buffer< T >::swap ( std::vector< T > &  in_data )

inherited

Use in_data as our data vector.

Definition at line 284 of file Buffer.h.

{
  std::swap(in_data, _data);
  this->_begin_pos = 0;
  this->_end_pos = this->_data.size();
}

Member Data Documentation

_begin_pos

template<typename T>

std::size_t MooseUtils::Buffer< T >::_begin_pos

protectedinherited

The beginning position.

Definition at line 208 of file Buffer.h.

Referenced by MooseUtils::Buffer< T >::begin(), MooseUtils::Buffer< T >::dataBeginPos(), MooseUtils::Buffer< T >::setSize(), and MooseUtils::Buffer< T >::size().

_data

template<typename T>

std::vector<T> MooseUtils::Buffer< T >::_data

protectedinherited

The raw data.

Definition at line 205 of file Buffer.h.

Referenced by MooseUtils::Buffer< T >::begin(), MooseUtils::Buffer< T >::capacity(), MooseUtils::Buffer< T >::data(), MooseUtils::Buffer< T >::end(), and MooseUtils::Buffer< T >::setCapacity().

_end_pos

template<typename T>

std::size_t MooseUtils::Buffer< T >::_end_pos

protectedinherited

The ending position.

Definition at line 210 of file Buffer.h.

Referenced by MooseUtils::Buffer< T >::dataEndPos(), MooseUtils::Buffer< T >::end(), MooseUtils::Buffer< T >::setSize(), and MooseUtils::Buffer< T >::size().

---

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

• include/utils/CircularBuffer.h