MCFsb.h

Go to the documentation of this file.

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

#ifndef MCFSBBASE_H
#define MCFSBBASE_H

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

#include "BufferBase.h"
#include "MCFheader.h"
#include "MRAsbBase.h"
#include "MRAsb.h"

class MCFsb
{
   public:

      MCFsb();

      MCFsb( const MCFsb& rhs );
      
      ~MCFsb();

      MCFsb& operator () ( MCFheader&, MRAsbBase&, string& );
      MCFsb& operator () ( MCFheader&, MRAsbBase&, char* = "" );

      MCFsb& operator () ( const MCFsb& );

      MCFsb& copy( const MCFsb& rhs );
      MCFsb& operator = ( const MCFsb& rhs );

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

      void write( istream& );
      MCFsb& operator << ( istream& );
      void read( ostream& );
      MCFsb& operator >> ( ostream& );

      void set_header( MCFheader& );
      void set_sb( MRAsbBase& );
      void set_postscript( string& );
      void set_postscript( char* );

      MCFheader* header();
      MRAsbBase* sb();
      string& postscript();

      int mcfsizeb();

   protected:
      
      MCFheader* _header;
      MRAsbBase* _sb;
      string _postscript;

   private:

   friend BufferBase& operator << ( BufferBase&, MCFsb& );
   friend BufferBase& operator >> ( BufferBase&, MCFsb& );

   friend ostream& operator<<( ostream&, MCFsb& );
   friend istream& operator>>( istream&, MCFsb& );

};

inline
MCFsb::MCFsb() : _header( new MCFheader ), _sb( new MRAsb ), _postscript("") {}

inline
MCFsb::MCFsb( const MCFsb& rhs ) 
 : _header( new MCFheader ), _sb( new MRAsb ), _postscript(rhs._postscript)
{
   _header = rhs._header;
   _sb = rhs._sb;
}

inline
MCFsb::~MCFsb()
{
   if ( _header != 0 ) { delete _header ; _header = 0; }
   if ( _sb != 0 ) { delete _sb ; _sb = 0; }
}

inline
MCFsb& MCFsb::operator () ( 
  MCFheader& header, MRAsbBase& sb, string& postscript 
)
{
   set_header(header);
   set_sb(sb);
   set_postscript(postscript);
   return *this;
}

inline
MCFsb& MCFsb::operator () (
  MCFheader& header, MRAsbBase& sb, char* postscript 
)
{
   set_header(header);
   set_sb(sb);
   set_postscript(postscript);
   return *this;
}

inline
MCFsb& MCFsb::operator () ( const MCFsb& mcfsb ) { return *this = mcfsb; }

inline
MCFsb& MCFsb::copy( const MCFsb& rhs ) 
{
   if ( this != &rhs ) {
      *_header = *(rhs._header);
      *_sb = *(rhs._sb);
      _postscript = rhs._postscript;
   }
   return *this;
}

inline
MCFsb& MCFsb::operator = ( const MCFsb& rhs ) { return copy(rhs); }

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

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

inline
MCFsb& MCFsb::operator << ( istream& is ) 
{
   write(is);
   return *this;
}

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

inline
void MCFsb::set_header( MCFheader& header ) { *_header = header; }

inline
void MCFsb::set_sb( MRAsbBase& sb ) { *_sb = sb; }

inline
void MCFsb::set_postscript( string& postscript ) { _postscript = postscript; }

inline
void MCFsb::set_postscript( char* postscript ) { _postscript = postscript; }

inline
MCFheader* MCFsb::header() { return _header; }

inline
MRAsbBase* MCFsb::sb() { return _sb; }

inline
string& MCFsb::postscript() { return _postscript; }

inline
int MCFsb::mcfsizeb() { return _header->sizeb() + _sb->sbsizeb() + 4; }

#endif

---