MCFTPheader.cpp

Go to the documentation of this file.

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

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

#include "utility.h"
#include "MCFheader.h"

#include "MCFTPheader.h"

MCFTPheader& MCFTPheader::operator () ()
{
   _tag = "MCFTP___";
   _id();
   _mcftpsizeb = -1;
   _version = 0;
   _revision = 2;
   _release = 0;
   _author = 0;
   _descript = "";
   return *this;
}

MCFTPheader& MCFTPheader::operator () ( const MCFheader& header )
{
   _tag = header._tag;
   _id();
   _mcftpsizeb = -1;
   _version = header._version;
   _revision = header._revision;
   _release = header._release;
   _author = header._author;
   _descript = header._descript;
   return *this;
}

MCFTPheader& MCFTPheader::operator () ( const MCFTPheader& header )
{
   _tag = header._tag;
   _id = header._id;
   _mcftpsizeb = header._mcftpsizeb;
   _version = header._version;
   _revision = header._revision;
   _release = header._release;
   _author = header._author;
   _descript = header._descript;
   return *this;
}

MCFTPheader& MCFTPheader::copy( const MCFTPheader& rhs )
{
   if ( this != &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;
   }
   return *this;
}

MCFTPheader& MCFTPheader::copy( const MCFheader& rhs )
{
   _tag = rhs._tag;
   _id();
   _mcftpsizeb = rhs._mcfsizeb;
   _version = rhs._version;
   _revision = rhs._revision;
   _release = rhs._release;
   _author = rhs._author;
   _descript = rhs._descript;
   return *this;
}

bool MCFTPheader::is_equal( const MCFTPheader& rhs )
{
   if ( this != &rhs ) {
      if ( _tag != rhs._tag ) return false;
      if ( _id != rhs._id ) return false;
      if ( _mcftpsizeb != rhs._mcftpsizeb ) return false;
      if ( _version != rhs._version ) return false;
      if ( _revision != rhs._revision ) return false;
      if ( _release != rhs._release ) return false;
      if ( _author != rhs._author ) return false;
      if ( _descript != rhs._descript ) return false;
   }
   return true;
}

void MCFTPheader::write( BufferBase& buffer )
{
   bytepack bp;
   _tag = "";
   for( int i = 0; i < 8; ++i ) _tag += buffer.get();
   buffer >> _id;
   buffer >> bp( 0, 4 ); _mcftpsizeb = int(bp);
   buffer >> bp( 0, 1 ); _version = int(bp);
   buffer >> bp( 0, 1 ); _revision = int(bp);
   buffer >> bp( 0, 1 ); _release = int(bp);
   buffer >> bp( 0, 1 ); _author = int(bp);
   buffer >> bp( 0, 1 ); int descriptsize = int(bp);
   _descript = "";
   for( int i = 0; i < descriptsize; ++i ) _descript += buffer.get();
}

void MCFTPheader::read( BufferBase& buffer )
{
   bytepack bp;
   for( int i = 0; i < 8; ++i ) buffer.put( _tag[i] );
   buffer << _id;
   buffer << bp( _mcftpsizeb, 4 );
   buffer << bp( _version, 1 );
   buffer << bp( _revision, 1 );
   buffer << bp( _release, 1 );
   buffer << bp( _author, 1 );
   buffer << bp( int(_descript.size()), 1 );
   for(unsigned int i = 0; i < _descript.size(); ++i) buffer.put(_descript[i]);
}

void MCFTPheader::write( istream& is )
{
   bytepack bp;
   _tag = "";
   for( int i = 0; i < 8; ++i ) _tag += is.get();
   is >> _id;
   is >> bp( 0, 4 ); _mcftpsizeb = int(bp);
   is >> bp( 0, 1 ); _version = int(bp);
   is >> bp( 0, 1 ); _revision = int(bp);
   is >> bp( 0, 1 ); _release = int(bp);
   is >> bp( 0, 1 ); _author = int(bp);
   is >> bp( 0, 1 ); int descriptsize = int(bp);
   _descript = "";
   for( int i = 0; i < descriptsize; ++i ) _descript += is.get();
}

void MCFTPheader::read( ostream& os )
{
   bytepack bp;
   for( int i = 0; i < 8; ++i ) os.put( _tag[i] );
   os << _id;
   os << bp( _mcftpsizeb, 4 );
   os << bp( _version, 1 );
   os << bp( _revision, 1 );
   os << bp( _release, 1 );
   os << bp( _author, 1 );
   os << bp( int(_descript.size()), 1 );
   for(unsigned int i = 0; i < _descript.size(); ++i) os.put(_descript[i]);
}

void MCFTPheader::report( ostream& os )
{
   os << "MCFTPheader::report(){\n";
   os << "tag = |" << _tag << "|;\n";
   os << "id =\n";
   _id.report();
   os << "mcftpsizeb = " << _mcftpsizeb << '\n';
   os << "version = " << _version << '\n';
   os << "revision = " << _revision << '\n';
   os << "release = " << _release << '\n';
   os << "author = " << _author << '\n';
   os << "descript.size() = " << _descript.size() << '\n';
   os << "descript = |" << _descript << "|\n";
   os << "}\n";
}

// ##### friends #####

BufferBase& operator << ( BufferBase& buffer, MCFTPheader& header )
{
   header.read(buffer);
   return buffer;
}

BufferBase& operator >> ( BufferBase& buffer, MCFTPheader& header )
{
   header.write(buffer);
   return buffer;
}

ostream& operator << ( ostream& os, MCFTPheader& header )
{
   header.read(os);
   return os;
}

istream& operator >> ( istream& is, MCFTPheader& header )
{
   header.write(is);
   return is;
}

---