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();
}
 
}