CircularBuffer.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Buffer.h"

namespace MooseUtils
{

template <typename T>
class CircularBuffer : public Buffer<T>
{
public:
  CircularBuffer();

  CircularBuffer(const std::size_t capacity);

  virtual void erase(const std::size_t num) override;
  virtual void eraseChunk(const std::size_t chunk_size) override;

  virtual typename Buffer<T>::iterator beginChunk(const std::size_t chunk_size) override;
  virtual typename Buffer<T>::const_iterator
  beginChunk(const std::size_t chunk_size) const override;
  virtual typename Buffer<T>::iterator endChunk(const std::size_t chunk_size) override;
  virtual typename Buffer<T>::const_iterator endChunk(const std::size_t chunk_size) const override;

protected:
  virtual std::size_t newEnd(const std::size_t new_end) override;
};

template <typename T>
CircularBuffer<T>::CircularBuffer() : Buffer<T>()
{
}

template <typename T>
CircularBuffer<T>::CircularBuffer(const std::size_t capacity) : Buffer<T>(capacity)
{
}

template <typename T>
void
CircularBuffer<T>::erase(const std::size_t num)
{
  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();
}

template <typename T>
void
CircularBuffer<T>::eraseChunk(const std::size_t chunk_size)
{
  if (chunk_size > this->size())
    this->erase(this->size());
  else
    this->erase(chunk_size);
}

template <typename T>
typename Buffer<T>::iterator
CircularBuffer<T>::beginChunk(const std::size_t /* chunk_size */)
{
  return this->begin();
}

template <typename T>
typename Buffer<T>::const_iterator
CircularBuffer<T>::beginChunk(const std::size_t /* chunk_size */) const
{
  return this->begin();
}

template <typename T>
typename Buffer<T>::iterator
CircularBuffer<T>::endChunk(const std::size_t chunk_size)
{
  if (chunk_size > this->size())
    return this->end();
  else
    return this->begin() + chunk_size;
}

template <typename T>
typename Buffer<T>::const_iterator
CircularBuffer<T>::endChunk(const std::size_t chunk_size) const
{
  if (chunk_size > this->size())
    return this->end();
  else
    return this->begin() + chunk_size;
}

template <typename T>
std::size_t
CircularBuffer<T>::newEnd(const std::size_t new_end)
{
  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;
}

}