BufferBase.h

Go to the documentation of this file.

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

#ifndef BUFFERBASE_H
#define BUFFERBASE_H

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

#include "utility.h"

class BufferBase
{
   public:

      virtual string isa() const { return "BufferBase"; }

      static const int goodbit = 0x01;
      static const int failbit = 0x02;
      static const int eobbit  = 0x04;
      static const int badbit  = 0x08;

      enum SeekDir{ beg, cur, end };

      BufferBase();

      BufferBase( const BufferBase& );

      virtual ~BufferBase();

      virtual BufferBase& operator = ( BufferBase& );

      void write( BufferBase& );
      BufferBase& operator << ( BufferBase& );
      void read( BufferBase& );
      BufferBase& operator >> ( BufferBase& );

      void write( bytepack& );
      BufferBase& operator << ( bytepack& );
      void read( bytepack& );
      BufferBase& operator >> ( bytepack& );

      void read( ostream& );
      BufferBase& operator >> ( ostream& );

      virtual void seekp( int, SeekDir dir = beg );
      virtual void seekg( int, SeekDir dir = beg );

      virtual void clear( int state = BufferBase::goodbit );
      virtual void setstate( int state );
      virtual void clrstate( int state );
      virtual int rdstate();
      virtual bool good();
      virtual bool fail();
      virtual bool eob();
      virtual bool bad();

      virtual int tellp();
      virtual int tellg();

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

      virtual void put( int, char );
      virtual void get( int, char& );
      virtual char get( int );

      virtual int size();

      virtual void erase();

   protected:

      int _size;
      int _putpos;
      int _getpos;
      int _state;

};

inline
BufferBase::BufferBase() 
  : _size(0), 
    _putpos(0), _getpos(0), 
    _state( BufferBase::goodbit ) 
{}

inline
BufferBase::BufferBase( const BufferBase& rhs ) 
  : _size( rhs._size ), 
    _putpos( rhs._putpos ), _getpos( rhs._getpos ), 
    _state( rhs._state ) 
{}

inline
BufferBase::~BufferBase() {}

inline
BufferBase& BufferBase::operator = ( BufferBase& rhs ) 
{
   if ( this != &rhs ) {
      _size = rhs._size;
      _putpos =  rhs._putpos;
      _getpos =  rhs._getpos;
      _state =  rhs._state;
   }
   return *this;
}

inline
void BufferBase::write( BufferBase& buffer )
{
   buffer.seekg(0);
   while ( !buffer.eob() ) { put( buffer.get() ); }
}

inline
BufferBase& BufferBase::operator << ( BufferBase& buffer )
{
   write(buffer);
   return *this;
}

inline
void BufferBase::read( BufferBase& buffer )
{
   seekg(0);
   while ( !eob() ) buffer.put( get() );
}

inline
BufferBase& BufferBase::operator >> ( BufferBase& buffer )
{
   read(buffer);
   return *this;
}

inline
void BufferBase::write( bytepack& bp )
{
   for( int i = 0; i < bp.size(); ++i ) put( bp[i] );
}

inline
BufferBase& BufferBase::operator << ( bytepack& bp )
{
   write(bp);
   return *this;
}

inline
void BufferBase::read( bytepack& bp )
{
   for( int i = 0; i < bp.size(); ++i ) bp[i] = get();
}

inline
BufferBase& BufferBase::operator >> ( bytepack& bp )
{
   read(bp);
   return *this;
}

inline
void BufferBase::read( ostream& os )
{
   while ( !eob() ) os.put( get() );
}

inline
BufferBase& BufferBase::operator >> ( ostream& os )
{
   read(os);
   return *this;
}

inline void BufferBase::clear( int state ) { _state = state; }

inline void BufferBase::setstate( int state ) { _state |= state; }
inline void BufferBase::clrstate( int state ) { _state &= !state; }

inline int BufferBase::rdstate() { return _state; }

inline bool BufferBase::good() { return _state == 1; }
inline bool BufferBase::fail() { return (_state & BufferBase::failbit) != 0; }
inline bool BufferBase::bad() { return (_state & BufferBase::badbit) != 0; }
inline bool BufferBase::eob() { return (_state & BufferBase::eobbit) != 0; }

inline
void BufferBase::seekp( int pos, BufferBase::SeekDir dir ) 
{
   int tmp = pos;

   if ( dir == BufferBase::cur ) tmp += _putpos;
   if ( dir == BufferBase::end ) tmp += _size;

   if ( ( tmp >= 0 ) && ( tmp <= _size ) )  _putpos = tmp;
   else setstate( BufferBase::failbit );
}

inline
void BufferBase::seekg( int pos, BufferBase::SeekDir dir ) 
{
   clrstate( BufferBase::eobbit );

   int tmp = pos;

   if ( dir == BufferBase::cur ) tmp += _getpos;
   if ( dir == BufferBase::end ) tmp += _size;

   if ( ( tmp >= 0 ) && ( tmp < _size ) )  _getpos = tmp;
   else setstate( BufferBase::failbit );

   if ( _getpos == _size )  setstate( BufferBase::eobbit );
}

inline
int BufferBase::tellp() { return _putpos; }

inline
int BufferBase::tellg() { return _getpos; }

inline
void BufferBase::put( char c )
{
   if ( _putpos++ == _size ) ++_size;
}

inline
void BufferBase::get( char& c )
{
   if ( !eob() ) {
      if ( ++_getpos == _size ) setstate( BufferBase::eobbit );
   }
   else setstate( BufferBase::failbit );
}

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

inline
void BufferBase::put( int pos, char c )
{
   seekp(pos);
   put(c);
}

inline
void BufferBase::get( int pos, char& c )
{
   seekg(pos);
   get(c);
}

inline
char BufferBase::get( int pos )
{
   seekg(pos);
   return get();
}

inline
int BufferBase::size() { return _size; }

inline
void BufferBase::erase() 
{
   _size = 0;
   _putpos = 0;
   _getpos = 0;
   clear( BufferBase::goodbit );
}

#endif

---