circular_buffer.h

Go to the documentation of this file.

#ifndef CIRCULAR_BUFFER_H
#define CIRCULAR_BUFFER_H

#include <itpp/base/vec.h>
#include <itpp/base/array.h>


namespace itpp
{

template<class T>
class Circular_Buffer
{
public:
  Circular_Buffer();

  Circular_Buffer(int n);

  Circular_Buffer(const Circular_Buffer<T> &s);

  virtual ~Circular_Buffer();

  void put(const T& in);

  void put(const Vec<T>& in);

  void put(const Array<T>& in);

  void get(T& out);

  T get();

  void get(Vec<T>& out, const int N = -1);

  void get(Array<T>& out, const int N = -1);

  void peek(T& out) const;

  T peek() const;

  void peek(const int index, T& out) const;

  void peek(Vec<T>& out, const int N = -1) const;

  void peek(const ivec& index, Vec<T>& out) const;

  void peek(Array<T>& out, const int N = -1) const;

  void peek(const ivec& index, Array<T>& out) const;

  void peek_reverse(T& out) const;

  T peek_reverse() const;

  void peek_reverse(Vec<T>& out, const int N = -1) const;

  void peek_reverse(Array<T>& out, const int N = -1) const;

  void clear();

  void operator=(const Circular_Buffer<T> &s);

  int size() const { return _ndata; }

  int nrof_elements() const { return _rw_dist; }

  void set_size(int n, bool copy = false);

private:

  int _write;
  int _read;
  int _ndata;
  int _rw_dist;
  T *_data;

  void alloc(int n);
  void free();

};

// --------------------------- Implementation starts here ----------------------------------

template<class T>
Circular_Buffer<T>::Circular_Buffer()
{
  _data    = 0;
  _ndata   = 0;
  _rw_dist = 0;
  _read    = 0;
  _write   = 0;
}

template<class T>
Circular_Buffer<T>::Circular_Buffer(int n)
{
  alloc(n);
  _read    = 0;
  _write   = 0;
  _rw_dist = 0;
}

template<class T>
Circular_Buffer<T>::Circular_Buffer(const Circular_Buffer<T> &cb)
{
  _data    = NULL;
  _ndata   = 0;
  _read    = cb._read;
  _write   = cb._write;
  _rw_dist = cb._rw_dist;

  alloc(cb._ndata);
  for (int i = 0; i < cb._ndata; i++) { _data[i] = cb._data[i]; }
}

template<class T>
Circular_Buffer<T>::~Circular_Buffer()
{
  free();
}

template <class T>
void Circular_Buffer<T>::get(T& out)
{
  it_assert_debug(_rw_dist > 0, "Buffer empty. No data left to read from the buffer.");
  out = _data[_read];
  _read++;
  _rw_dist--;

  if (_read == _ndata) { _read = 0; }
}

template <class T>
T Circular_Buffer<T>::get()
{
  T out;

  get(out);
  return out;
}

template <class T>
void Circular_Buffer<T>::get(Vec<T>& out, const int N)
{
  int N_out;

  if (N == -1)
    N_out = _rw_dist;
  else
    N_out = N;

  out.set_size(N_out);

  for (int i = 0;i < N_out;i++) {
    it_assert_debug(_rw_dist > 0, "Buffer empty. No data left to read from the buffer.");
    out(i) = _data[_read];
    _read++;
    _rw_dist--;

    if (_read == _ndata)
      _read = 0;
  }
}

template <class T>
void Circular_Buffer<T>::get(Array<T>& out, const int N)
{
  int N_out;

  if (N == -1)
    N_out = _rw_dist;
  else
    N_out = N;

  out.set_size(N_out);

  for (int i = 0;i < N_out;i++) {
    it_assert_debug(_rw_dist > 0, "Buffer empty. No data left to read from the buffer.");
    out(i) = _data[_read];
    _read++;
    _rw_dist--;

    if (_read == _ndata)
      _read = 0;
  }
}

template <class T>
void Circular_Buffer<T>::peek(T& out) const
{
  it_assert_debug(_rw_dist > 0, "Attempted to peek at an empty buffer.");
  out = _data[_read];
}

template <class T>
T Circular_Buffer<T>::peek() const
{
  T out;

  peek(out);
  return out;
}

template <class T>
void Circular_Buffer<T>::peek(const int index, T& out) const
{
  it_assert_debug(_rw_dist > index && index >= 0, "The index exceeds the number of elements stored in the buffer.");
  out = _data[(_read+index)%_ndata];
}

template <class T>
void Circular_Buffer<T>::peek(Vec<T>& out, const int N) const
{
  int N_out;
  int read_tmp = _read;

  if (N == -1)
    N_out = _rw_dist;
  else
    N_out = N;

  it_assert_debug(_rw_dist >= N_out, "Attempted to peek at more elements than there are stored in the buffer.");
  out.set_size(N_out);

  for (int i = 0;i < N_out;i++) {
    out(i) = _data[read_tmp];
    read_tmp++;
    if (read_tmp == _ndata)
      read_tmp = 0;
  }
}

template <class T>
void Circular_Buffer<T>::peek(const ivec& index, Vec<T>& out) const
{
  out.set_size(index.size());

  for (int i = 0;i < index.size();i++) {
    it_assert_debug(_rw_dist >= index(i) && index(i) >= 0, "Attempted to peek at an element, whose index exceeds the number of buffered elements.");
    out(i) = _data[(_read+index(i))%_ndata];
  }
}

template <class T>
void Circular_Buffer<T>::peek(Array<T>& out, const int N) const
{
  int N_out;
  int read_tmp = _read;

  if (N == -1)
    N_out = _rw_dist;
  else
    N_out = N;

  it_assert_debug(_rw_dist >= N_out, "Attempted to peek at more elements than there are stored in the buffer.");
  out.set_size(N_out);

  for (int i = 0;i < N_out;i++) {
    out(i) = _data[read_tmp];
    read_tmp++;
    if (read_tmp == _ndata)
      read_tmp = 0;
  }
}

template <class T>
void Circular_Buffer<T>::peek(const ivec& index, Array<T>& out) const
{
  out.set_size(index.size());

  for (int i = 0;i < index.size();i++) {
    it_assert_debug(_rw_dist >= index(i) && index(i) >= 0, "Attempted to peek at an element, whose index exceeds the number of buffered elements.");
    out(i) = _data[(_read+index(i))%_ndata];
  }
}

template <class T>
void Circular_Buffer<T>::peek_reverse(T& out) const
{
  int read_tmp;

  it_assert_debug(_rw_dist > 0, "Attempted to peek at an empty buffer.");

  if (_write > 0)
    read_tmp = _write - 1;
  else
    read_tmp = _ndata - 1;

  out = _data[read_tmp];
}

template <class T>
T Circular_Buffer<T>::peek_reverse() const
{
  T out;

  peek_reverse(out);
  return out;
}

template <class T>
void Circular_Buffer<T>::peek_reverse(Vec<T>& out, const int N) const
{
  int N_out;
  int read_tmp;

  if (N == -1)
    N_out = _rw_dist;
  else
    N_out = N;

  it_assert_debug(_rw_dist >= N_out, "Attempted to peek at more elements than there are stored in the buffer.");
  out.set_size(N_out);

  if (_write > 0)
    read_tmp = _write - 1;
  else
    read_tmp = _ndata - 1;

  for (int i = 0;i < N_out;i++) {
    out(i) = _data[read_tmp];
    read_tmp--;
    if (read_tmp < 0)
      read_tmp = _ndata - 1;
  }
}

template <class T>
void Circular_Buffer<T>::peek_reverse(Array<T>& out, const int N) const
{
  int N_out;
  int read_tmp;

  if (N == -1)
    N_out = _rw_dist;
  else
    N_out = N;

  it_assert_debug(_rw_dist >= N_out, "Attempted to peek at more elements than there are stored in the buffer.");
  out.set_size(N_out);

  if (_write > 0)
    read_tmp = _write - 1;
  else
    read_tmp = _ndata - 1;

  for (int i = 0;i < N_out;i++) {
    out(i) = _data[read_tmp];
    read_tmp--;
    if (read_tmp < 0)
      read_tmp = _ndata - 1;
  }
}

template <class T>
void Circular_Buffer<T>::put(const T& in)
{
  //Remove the oldest element of the buffer if the buffer is full
  if (_rw_dist >= _ndata) {
    T dummy;
    get(dummy);
  }

  //Write data to the buffer and move the pointer to the next buffer slot
  _data[_write] = in;
  _write++;
  _rw_dist++;

  //Check if the pointer in the circular buffer should go back to zero
  if (_write >= _ndata)
    _write = 0;

}

template <class T>
void Circular_Buffer<T>::put(const Vec<T>& in)
{
  for (int i = 0;i < in.size();i++) {
    //Remove the oldest element of the buffer if the buffer is full
    if (_rw_dist >= _ndata) {
      T dummy;
      get(dummy);
    }

    //Write data to the buffer and move the pointer to the next buffer slot
    _data[_write] = in(i);
    _write++;
    _rw_dist++;

    //Check if the pointer in the circular buffer should go back to zero
    if (_write >= _ndata)
      _write = 0;
  }

}

template <class T>
void Circular_Buffer<T>::put(const Array<T>& in)
{
  for (int i = 0;i < in.size();i++) {
    //Remove the oldest element of the buffer if the buffer is full
    if (_rw_dist >= _ndata) {
      T dummy;
      get(dummy);
    }

    //Write data to the buffer and move the pointer to the next buffer slot
    _data[_write] = in(i);
    _write++;
    _rw_dist++;

    //Check if the pointer in the circular buffer should go back to zero
    if (_write >= _ndata)
      _write = 0;
  }
}

template <class T>
void Circular_Buffer<T>::clear()
{
  _write   = 0;
  _read    = 0;
  _rw_dist = 0;
}

template<class T>
void Circular_Buffer<T>::alloc(int n)
{
  if (n == 0) {
    _ndata = 0;
    _data  = NULL;
  }
  else if (n > 0) {
    _ndata = n;
    _data = new T[_ndata];
    it_assert(_data != 0, "Out of memory in Circular_Buffer::alloc");
  }
  else {
    it_error("Circular_Buffer<T>::alloc(int n): n must be positive");
  }
}

template<class T>
void Circular_Buffer<T>::free()
{
  delete [] _data;

  _data    = NULL;
  _ndata   = 0;
  _write   = 0;
  _read    = 0;
  _rw_dist = 0;
}

template<class T>
void Circular_Buffer<T>::operator=(const Circular_Buffer<T> &s)
{
  set_size(s._ndata);
  for (int i = 0; i < _ndata; i++)
    _data[i] = s._data[i];
  _read = s._read;
  _write = s._write;
  _rw_dist = _write - _read;
}

template<class T>
void Circular_Buffer<T>::set_size(int sz, bool copy)
{
  int i, min_nrof_elem;
  //T *tmp;
  Vec<T> tmp;

  if (_ndata == sz)
    return;

  if (copy) {
    peek_reverse(tmp, -1);
    min_nrof_elem = _rw_dist < sz ? _rw_dist : sz;
    alloc(sz);
    clear();
    for (i = 0; i < min_nrof_elem; i++)
      put(tmp(min_nrof_elem - 1 - i));
  }
  else {
    free();
    alloc(sz);
  }

  _ndata = sz;
}

} // namespace itpp

#endif // #ifndef CIRCULAR_BUFFER_H