ssBuffer.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:     Tim George     Date: July 2004

#ifndef _ssBuffer_
#define _ssBuffer_

#define NUM_BUFFERS 2

template <class dataType>
class ssBuffer 
{
private:
   int *_size;
   int _numBuf;
   int _curBuffer;
   dataType **_data;

public:
   ssBuffer(int size, int numBuf)
   {
      _curBuffer = 0;
      _numBuf = 0;
      _size = NULL;
      _data = NULL;
      
      if(numBuf<1) return;

      _size = new int[numBuf];
      _data = new dataType*[numBuf];
      _numBuf = numBuf;

      for(int i = 0; i < _numBuf; i++)
      {  
         _data[i] = new dataType[size];
         _size[i] = size;
      }

      return;
   };

   ssBuffer& operator=( const ssBuffer& copy )
   {
      _numBuf = copy._numBuf;
      _curBuffer = (copy._curBuffer % _numBuf);

      delete [] _size;
      _size = new int[_numBuf];
      
      delete [] _data;
      _data = new dataType[_numBuf];

      for(int i = 0; i < _numBuf; i++)
      {
         _size[i] = copy._size[i];
         _data[i] = new dataType[copy.size[i]];
         memcpy(_data[i], copy._data[i], copy.size[i]);
      }

      return *this;
   }

   ssBuffer(const ssBuffer& copy)
   {
      _numBuf = copy._numBuf;
      _curBuffer = (copy._curBuffer % _numBuf);

      _size = new int[_numBuf];
      _data = new dataType[_numBuf];

      for(int i = 0; i < _numBuf; i++)
      {
         _size[i] = copy._size[i];
         _data[i] = new dataType[copy.size[i]];
         memcpy(_data[i], copy._data[i], copy.size[i]);
      }
   }

   ~ssBuffer()
   {
      for(int i = 0; i < _numBuf; i++)
      {
         delete [] _data[i];
      }
      delete [] _data;
      delete [] _size;
   };

   void addData(int size)
   {
      if(!_data) return;
      if(!_size) return;
      int nextBuf = ((_curBuffer + 1) % _numBuf);
      if(_data[nextBuf]) delete [] _data[nextBuf];
      _size[nextBuf] = size;
      _data[nextBuf] = new dataType[size]; 
   }

   dataType *getNextData()
   {
      if(!_data) return NULL;
      int nextBuf = ((_curBuffer + 1) % _numBuf);
      return _data[nextBuf];
   };

   void useNextData()
   {
      _curBuffer = ((_curBuffer + 1) % _numBuf);
   }

   void copy(dataType *copy)
   {
      if(!_size) return;
      if(!_data) return;
      int nextBuf = ((_curBuffer + 1) % _numBuf);
      if(!(_data[nextBuf])) return;
      for(int i = 0; i < _size[nextBuf]; i++)
      {
         _data[nextBuf][i] = copy[i];
      }
      _curBuffer = nextBuf;
   }

   dataType *getDataPtr()
   {
      if(!_data) return NULL;
      if(_curBuffer>_numBuf-1) return NULL;
      return _data[_curBuffer];
   }

   dataType& operator [] (const int nIdx)
   {
      if(!_data) return 0;
      if(_curBuffer>_numBuf-1) return 0;
      if(!(_data[_curBuffer])) return 0;
      if(!_size) return 0;
      if(nIdx<_size[_curBuffer]-1) return 0;
      return _data[_curBuffer][nIdx]; 
   };

   
};

#endif