MCFheader.h

Go to the documentation of this file.

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

#ifndef MCFHEADER_H
#define MCFHEADER_H

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

#include "BufferBase.h"

class MCFTPheader;

class MCFheader
{
   public:

      MCFheader();
      MCFheader( const MCFTPheader& rhs );
      MCFheader( const MCFheader& rhs );

      MCFheader& operator () ();
      MCFheader& operator () ( const MCFheader& );
      MCFheader& operator () ( const MCFTPheader& );

      MCFheader& copy( const MCFheader& rhs );
      MCFheader& copy( const MCFTPheader& rhs );
      MCFheader& operator = ( const MCFheader& rhs );
      MCFheader& operator = ( const MCFTPheader& rhs );

      bool is_equal( const MCFheader& rhs );
      bool operator == ( const MCFheader& rhs );
      bool operator != ( const MCFheader& rhs );

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

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

      void set_tag( string& tag );
      void set_tag( char* tag );
      void set_mcfsizeb( int mcfsizeb );
      void set_version( int version );
      void set_revision( int revision );
      void set_release( int release );
      void set_author( int author );
      void set_descript( string& descript );
      void set_descript( char* descript );

      string& tag();
      int mcfsizeb();
      int version();
      int revision();
      int release();
      int author();
      int descriptsize();
      string& descript();

      int sizeb();

      void report( ostream& = cout );

   protected:
      string _tag;
      int _mcfsizeb;
      int _version;
      int _revision;
      int _release;
      int _author;
      string _descript;

   friend class MCFTPheader;

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

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

};

#include "MCFTPheader.h"

inline
MCFheader::MCFheader()
  : _tag("MCF_____"), _mcfsizeb(0), 
    _version(0), _revision(2), _release(0),
    _author(0), _descript("")
{}

inline
MCFheader::MCFheader( const MCFTPheader& rhs )
  : _tag(rhs._tag), _mcfsizeb(rhs._mcftpsizeb), 
    _version(rhs._version), _revision(rhs._revision), _release(rhs._release),
    _author(rhs._author), _descript(rhs._descript)
{}

inline
MCFheader::MCFheader( const MCFheader& rhs )
  : _tag(rhs._tag), _mcfsizeb(rhs._mcfsizeb), 
    _version(rhs._version), _revision(rhs._revision), _release(rhs._release),
    _author(rhs._author), _descript(rhs._descript)
{}

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

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

inline
bool MCFheader::operator == ( const MCFheader& rhs ) { return is_equal(rhs); }

inline
bool MCFheader::operator != ( const MCFheader& rhs ) { return !is_equal(rhs); }

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

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

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

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

inline
void MCFheader::set_tag( string& tag ) { _tag = tag; }

inline
void MCFheader::set_tag( char* tag ) { _tag = tag; }

inline
void MCFheader::set_mcfsizeb( int mcfsizeb ) { _mcfsizeb = mcfsizeb; }

inline
void MCFheader::set_version( int version ) { _version = version; }

inline
void MCFheader::set_revision( int revision ) { _revision = revision; }

inline
void MCFheader::set_release( int release ) { _release = release; }

inline
void MCFheader::set_author( int author ) { _author = author; }

inline
void MCFheader::set_descript( string& descript ) { _descript = descript; }

inline
void MCFheader::set_descript( char* descript ) { _descript = descript; }

inline
string& MCFheader::tag() { return _tag; }

inline
int MCFheader::mcfsizeb() { return _mcfsizeb; }

inline
int MCFheader::version() { return _version; }

inline
int MCFheader::revision() { return _revision; }

inline
int MCFheader::release() { return _release; }

inline
int MCFheader::author() { return _author; }

//inline
//int MCFheader::descriptsize() { return _descript.size(); }

inline
string& MCFheader::descript() { return _descript; }

inline
int MCFheader::sizeb() { return 17 + _descript.size(); }

#endif

---