Buffer.h

Go to the documentation of this file.

// Buffer.h
//////////////////////////////////////////////////////////////////////
//          (c) Copyright 2002 Brown Deer Technology, LLC.
//                        All rights reserved.
//////////////////////////////////////////////////////////////////////

#ifndef BUFFER_H
#define BUFFER_H

#ifdef USE_STD
#include <iostream>
#include <string>
using namespace std;
#else
#include <iostream.h>
#include <string.h>
#endif

#include "BufferBase.h"

#define BUFFER_DEFAULT_SIZEMAX 256

class Buffer : public BufferBase
{
   public:
      
      string isa() const { return "Buffer"; }

      Buffer( int sizemax = BUFFER_DEFAULT_SIZEMAX );

      Buffer( const Buffer& rhs );

      Buffer( BufferBase& buf );

      ~Buffer();

      Buffer& operator = ( Buffer& rhs );

      void put( char c );
      void get( char& c );
      char get();

      void put( int i, char c );
      void get( int i, char& c );
      char get( int i );

      void resizemax( int sizemax = BUFFER_DEFAULT_SIZEMAX );

      void erase();

      const char* c_str();

   protected:
      int _sizemax;
      char* _data;

};

inline
Buffer::Buffer( int sizemax )
  : _sizemax(sizemax)
{
   _data = new char[sizemax];
}

inline
Buffer::Buffer( const Buffer& rhs )
  : BufferBase(rhs),
    _sizemax(rhs._sizemax)
{
   _data = new char[rhs._sizemax];
   for( int i = 0; i < rhs._size; ++i ) _data[i] = rhs._data[i];
}

inline
Buffer::Buffer( BufferBase& buf )
  : BufferBase(buf),
    _sizemax(BUFFER_DEFAULT_SIZEMAX) 
{
   _data = new char[BUFFER_DEFAULT_SIZEMAX];
   buf.seekg(0);
   for( int i = 0; i < buf.size(); ++i ) buf.get( _data[i] );
}

inline
Buffer::~Buffer() 
{
   if ( _data != 0 ) { delete [] _data; _data = 0; }
}

inline
Buffer& Buffer::operator = ( Buffer& rhs )
{
   if ( this != &rhs ) {
      BufferBase::operator=(rhs);
      resizemax( rhs._sizemax );
      for( int i = 0; i < rhs._size; ++i ) _data[i] = rhs._data[i];
   }
   return *this;
}

inline 
void Buffer::put( char c )
{
   if ( _size == _sizemax ) resizemax( _sizemax * 2 );
   _data[_putpos] = c;
   BufferBase::put(c); 
}

inline
void Buffer::get( char& c )
{
   if ( !eob() ) {
      c = _data[ _getpos ];
//      cout << "Buffer:got " << _getpos << ' ' << int((unsigned char)c) << endl;
      BufferBase::get(c);
   }
   else setstate( BufferBase::failbit );
}

inline char Buffer::get() { return BufferBase::get(); }

inline void Buffer::put( int i, char c ) { BufferBase::put(i,c); }
inline void Buffer::get( int i, char& c ) { BufferBase::get(i,c); }
inline char Buffer::get( int i ) { return BufferBase::get(i); }

inline
void Buffer::resizemax( int sizemax ) 
{
   char* tmp = new char[sizemax];
   _sizemax = sizemax;
   for( int i = 0; i < size(); ++i ) tmp[i] = _data[i];
   char* tmp2 = _data;
   _data = tmp;
   if ( tmp2 != 0 ) { delete [] tmp2; }
}

inline
void Buffer::erase() 
{ 
   BufferBase::erase();
   resizemax(); 
}

inline 
const char* Buffer::c_str() 
{ 
   _data[_size]=0; 
   return _data; 
}

#endif

---