Buffer.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 "MooseError.h"

#include <vector>

namespace MooseUtils
{

template <typename T>
class Buffer
{
public:
  typedef typename std::vector<T>::iterator iterator;
  typedef typename std::vector<T>::const_iterator const_iterator;

  Buffer();

  Buffer(const std::size_t capacity);

  virtual ~Buffer() {}

  void setCapacity(const std::size_t capacity) { this->_data.resize(capacity); }
  std::size_t capacity() const { return this->_data.size(); }

  void setSize(const std::size_t size) { this->_end_pos = this->newEnd(this->_begin_pos + size); }
  std::size_t size() const { return this->_end_pos - this->_begin_pos; }

  bool empty() const { return !size(); }

  void push_back(const T & value);

  void move(T & value);

  void append(const_iterator in_begin, const_iterator in_end);
  void append(const std::vector<T> & vals);

  void clear();

  virtual void erase(const std::size_t num) = 0;
  /*
   * Similar to erase(), but if the chunk size is larger than the current size,
   * no error (all elements are erased gracefully).
   *
   * Note that erased items are not guaranteed to be freed immediately
   */
  virtual void eraseChunk(const std::size_t chunk_size) = 0;

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

  iterator end() { return this->_data.begin() + this->_end_pos; }
  const_iterator end() const { return this->_data.begin() + this->_end_pos; }

  virtual iterator beginChunk(const std::size_t chunk_size) = 0;
  virtual const_iterator beginChunk(const std::size_t chunk_size) const = 0;

  virtual iterator endChunk(const std::size_t chunk_size) = 0;
  virtual const_iterator endChunk(const std::size_t chunk_size) const = 0;

  T & operator[](const std::size_t index);
  const T & operator[](const std::size_t index) const;

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

  const std::vector<T> & data() { return _data; }

  std::size_t dataBeginPos() const { return _begin_pos; }

  std::size_t dataEndPos() const { return _end_pos; }

protected:
  virtual std::size_t newEnd(const std::size_t new_end) = 0;

  std::vector<T> _data;

  std::size_t _begin_pos;
  std::size_t _end_pos;
};

template <typename T>
Buffer<T>::Buffer() : _begin_pos(0), _end_pos(0)
{
}

template <typename T>
Buffer<T>::Buffer(const std::size_t capacity) : _data(capacity), _begin_pos(0), _end_pos(0)
{
}

template <typename T>
void
Buffer<T>::push_back(const T & value)
{
  this->_end_pos = newEnd(this->_end_pos + 1);
  this->_data[this->_end_pos - 1] = value;
}

template <typename T>
void
Buffer<T>::move(T & value)
{
  this->_end_pos = newEnd(this->_end_pos + 1);
  this->_data[this->_end_pos - 1] = std::move(value);
}

template <typename T>
void
Buffer<T>::append(const_iterator in_begin, const_iterator in_end)
{
  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);
}

template <typename T>
void
Buffer<T>::append(const std::vector<T> & vals)
{
  this->append(vals.begin(), vals.end());
}

template <typename T>
void
Buffer<T>::clear()
{
  this->_begin_pos = 0;
  this->_end_pos = 0;
}

template <typename T>
T &
Buffer<T>::operator[](const std::size_t index)
{
  mooseAssert(this->_begin_pos + index < this->_end_pos, "Attempt to access off end of Buffer!");
  return this->_data[this->_begin_pos + index];
}

template <typename T>
const T &
Buffer<T>::operator[](const std::size_t index) const
{
  mooseAssert(this->_begin_pos + index < this->_end_pos, "Attempt to access off end of Buffer!");
  return this->_data[this->_begin_pos + index];
}

template <typename T>
void
Buffer<T>::swap(std::vector<T> & in_data)
{
  std::swap(in_data, _data);
  this->_begin_pos = 0;
  this->_end_pos = this->_data.size();
}

}