cirbuffarr.h

Go to the documentation of this file.

#ifndef CIRBUFFARR_H
#define CIRBUFFARR_H

;  // hack (compiler difficulties)
#include <cassert>
#include <iostream>
//;  // hack (compiler difficulties)
using namespace std;

typedef unsigned int uint;
typedef unsigned int const uintc;

template< typename T >
class cirbuffarr
{
  T * state;
  uint current;

  cirbuffarr() 
    { assert(false); }
public:

  uintc nstates; 

  uintc W;

  void operator ++ ()
    { ++current; current %= nstates; }
  void operator -- ()
    { current += (nstates-1); current %= nstates; }

  cirbuffarr(uintc nstates_, uintc W_);
  ~cirbuffarr();

  inline T * operator [] (uintc k);
  inline T const * operator [] (uintc k) const;

  template< typename Z >
  void operator = ( Z const & x );

  template< typename Z >
  void copyto( Z & x, uintc i=0 ) const;

  template< typename Z >
  void push( Z const & x );

  void dup();

  ostream & print(ostream & os) const;

};

template< typename T >
ostream & operator << (ostream & os, cirbuffarr<T> const & cir)
  { return cir.print(os); }


// ---------------------------------------------------------
// Implementation

template< typename T >
ostream & cirbuffarr<T>::print(ostream & os) const
{
  T const * s;
  uint i;
  uint k;
  for (i=0; i<nstates; ++i)
  {
    s = operator[](i); 
    os << i << ": ";
    for (k=0; k<W; ++k)
      os << s[k] << " ";
    os << endl;
  }

  return os;
}


template< typename T >
void cirbuffarr<T>::dup()
{
  T * prev = operator[](0); //accessState();
  push(prev);
}

template< typename T >
template< typename Z >
void cirbuffarr<T>::operator = ( Z const & x )
{
  T * c = operator[](0); //accessState(); 
  
  for (uint i=0; i<W; ++i)
    c[i] = x[i];
}

template< typename T >
template< typename Z >
void cirbuffarr<T>::push( Z const & x )
{
  operator ++();
  *this = x;
}

template< typename T >
template< typename Z >
void cirbuffarr<T>::copyto( Z & x, uintc i ) const
{
  T const * c = operator[](i);
  
  for (uint i=0; i<W; ++i)
    x[i] = c[i];
}

template< typename T >
T * cirbuffarr<T>::operator [] (uintc k)
{
  assert(k<nstates);
  assert(nstates!=0);
  return state + ((current+(nstates-k))%nstates)*W;
}

template< typename T >
T const * cirbuffarr<T>::operator [] (uintc k) const
{
  //assert(k<nstates);
  assert(nstates!=0);
  return state + ((current+(nstates-k))%nstates)*W;
}

template< typename T >
cirbuffarr<T>::cirbuffarr(uintc nstates_, uintc W_)
  : nstates(nstates_), W(W_)
{
  assert(nstates>0);
  current=0;
  state = new T[nstates*W];
}

template< typename T >
cirbuffarr<T>::~cirbuffarr()
{
  delete[] state;
  state = 0;
}


#endif