MCFTPheader.h

Go to the documentation of this file.

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

#ifndef MCFTPHEADER_H
#define MCFTPHEADER_H

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

#include "BufferBase.h"
#include "MCFTPid.h"

class MCFheader;

class MCFTPheader
{
   public:

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

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

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

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

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

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

      void set_tag( string& tag );
      void set_tag( char* tag );
      void set_id( MCFTPid );
      void set_mcftpsizeb( 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();
      MCFTPid id();
      int mcftpsizeb();
      int version();
      int revision();
      int release();
      int author();
//      int descriptsize();
      string& descript();

      int sizeb();

      void report( ostream& = cout );

   protected:
      string _tag;
      MCFTPid _id;
      int _mcftpsizeb;
      int _version;
      int _revision;
      int _release;
      int _author;
      string _descript;

   friend class MCFheader;

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

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

};

#include "MCFheader.h"

inline
MCFTPheader::MCFTPheader()
  : _tag("MCFTP___"), _mcftpsizeb(-1),
    _version(0), _revision(2), _release(0),
    _author(0), _descript("")
{}

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

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

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

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

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

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

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

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

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

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

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

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

inline
void MCFTPheader::set_id( MCFTPid id ) { _id = id; }

inline
void MCFTPheader::set_mcftpsizeb( int mcftpsizeb ) { _mcftpsizeb = mcftpsizeb; }

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

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

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

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

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

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

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

inline
MCFTPid MCFTPheader::id() { return _id; }

inline
int MCFTPheader::mcftpsizeb() { return _mcftpsizeb; }

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

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

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

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

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

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

inline
int MCFTPheader::sizeb() { return 33 + _descript.size(); }

#endif

---