MCFTPmssg.h

Go to the documentation of this file.

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

#ifndef MCFTPMSSG_H
#define MCFTPMSSG_H

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

#include "BufferBase.h"
#include "MRAsb.h"
#include "MCFTPheader.h"
#include "MCFTPrequest.h"
#include "MCFTPquote.h"

class MCFTPmssg
{
   public:

      enum MessageType{ 
        messagetype_unknown = 0, 
        messagetype_request = 1, 
        messagetype_quote = 2, 
        messagetype_mrasb = 3 
      };
      enum MessageQual{ 
         messagequal_none = 0, 
         messagequal_error = 1, 
         messagequal_notfound = 2, 
         messagequal_quoteonly = 3,
         messagequal_correction = 4,
         messagequal_notavailable = 5
      };

      static MessageType inttomessagetype( int i );
      static MessageQual inttomessagequal( int i );

      MCFTPmssg();

      MCFTPmssg( const MCFTPmssg& rhs );
      
      ~MCFTPmssg();

      MCFTPmssg& operator () ( const MCFTPmssg& );

      MCFTPmssg& operator () ();

      MCFTPmssg& operator () ( 
        MCFTPheader&, 
        MCFTPrequest&, string& 
      );
      MCFTPmssg& operator () ( 
        MCFTPheader&, MessageQual, 
        MCFTPrequest&, string& 
      );

      MCFTPmssg& operator () ( 
        MCFTPheader&, 
        MCFTPrequest&, MCFTPquote&, string& 
      );
      MCFTPmssg& operator () ( 
        MCFTPheader&, MessageQual, 
        MCFTPrequest&, MCFTPquote&, string& 
      );

      MCFTPmssg& operator () ( 
        MCFTPheader&,
        MCFTPrequest&, MCFTPquote&, MRAsbBase&, string& 
      );
      MCFTPmssg& operator () ( 
        MCFTPheader&, MessageQual, 
        MCFTPrequest&, MCFTPquote&, MRAsbBase&, string& 
      );

      MCFTPmssg& operator () ( 
        MCFTPheader&,
        MCFTPrequest&, char* = "" 
      );
      MCFTPmssg& operator () ( 
        MCFTPheader&, MessageQual, 
        MCFTPrequest&, char* = "" 
      );

      MCFTPmssg& operator () ( 
        MCFTPheader&,
        MCFTPrequest&, MCFTPquote&, char* = "" 
      );
      MCFTPmssg& operator () ( 
        MCFTPheader&, MessageQual,
        MCFTPrequest&, MCFTPquote&, char* = "" 
      );

      MCFTPmssg& operator () ( 
        MCFTPheader&,
        MCFTPrequest&, MCFTPquote&, MRAsbBase&, char* = "" 
      );
      MCFTPmssg& operator () ( 
        MCFTPheader&, MessageQual,
        MCFTPrequest&, MCFTPquote&, MRAsbBase&, char* = "" 
      );

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

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

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

      void set_header( MCFTPheader& );
      void set_messagetype( MessageType );
      void set_messagequal( MessageQual );
      void set_request( MCFTPrequest& );
      void set_quote( MCFTPquote& );
      void set_sb( MRAsbBase& );
      void set_postscript( string& );
      void set_postscript( char* );

      MCFTPheader* header();
      MessageType messagetype();
      MessageQual messagequal();
      MCFTPrequest* request();
      MCFTPquote* quote();
      MRAsbBase* sb();
      string& postscript();

      int mcftpsizeb();

      static string help( MessageType );
      static string help( MessageQual );

   protected:
      
      MCFTPheader* _header;
      MessageType _messagetype;
      MessageQual _messagequal;
      MCFTPrequest* _request;
      MCFTPquote* _quote;
      MRAsbBase* _sb;
      string _postscript;

   private:

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

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

};

inline
MCFTPmssg::MessageType MCFTPmssg::inttomessagetype( int i ) {
   switch (i) {
      case int(messagetype_unknown): return messagetype_unknown;
      case int(messagetype_request): return messagetype_request;
      case int(messagetype_quote): return messagetype_quote;
      case int(messagetype_mrasb): return messagetype_mrasb;
   }
}

inline
MCFTPmssg::MessageQual MCFTPmssg::inttomessagequal( int i ) {
   switch (i) {
      case int(messagequal_none): return messagequal_none; 
      case int(messagequal_quoteonly): return messagequal_quoteonly;
   }
}

inline
MCFTPmssg::MCFTPmssg() 
  : _header( new MCFTPheader ), 
    _messagetype(messagetype_unknown), 
    _messagequal(messagequal_none),
    _request( new MCFTPrequest ), _quote( new MCFTPquote ),
    _sb( new MRAsb ), _postscript("") {}

inline
MCFTPmssg::MCFTPmssg( const MCFTPmssg& rhs ) 
 : _header( new MCFTPheader ),
   _messagetype(rhs._messagetype), _messagequal(rhs._messagequal),
   _request( new MCFTPrequest ), _quote( new MCFTPquote ),
   _sb( new MRAsb ), _postscript(rhs._postscript)
{
   _header = rhs._header;
   _request = rhs._request;
   _quote = rhs._quote;
   _sb = rhs._sb;
   _header->set_mcftpsizeb( mcftpsizeb() );
}

inline
MCFTPmssg::~MCFTPmssg()
{
   if ( _header != 0 ) { delete _header ; _header = 0; }
   if ( _request != 0 ) { delete _request ; _request = 0; }
   if ( _quote != 0 ) { delete _quote ; _quote = 0; }
   if ( _sb != 0 ) { delete _sb ; _sb = 0; }
}

inline
MCFTPmssg& MCFTPmssg::operator () ( const MCFTPmssg& mcftpsb ) 
{ 
   return *this = mcftpsb; 
}

inline
MCFTPmssg& MCFTPmssg::operator () () 
{
   if ( _header != 0 ) { delete _header ; _header = 0; }
   if ( _request != 0 ) { delete _request ; _request = 0; }
   if ( _quote != 0 ) { delete _quote ; _quote = 0; }
   if ( _sb != 0 ) { delete _sb ; _sb = 0; }

   _header = new MCFTPheader;
   _messagetype = messagetype_unknown;
   _messagequal = messagequal_none;
   _request = new MCFTPrequest;
   _quote = new MCFTPquote;
   _sb = new MRAsb;
   _postscript = "";
   return *this;
}

inline
MCFTPmssg& MCFTPmssg::copy( const MCFTPmssg& rhs ) 
{
   if ( this != &rhs ) {
      *_header = *(rhs._header);
      _messagetype = rhs._messagetype;
      _messagequal = rhs._messagequal;
      *_request = *(rhs._request);
      *_quote = *(rhs._quote);
      *_sb = *(rhs._sb);
      _postscript = rhs._postscript;
   }
   return *this;
}

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

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

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

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

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

inline
void MCFTPmssg::set_header( MCFTPheader& header ) { *_header = header; }

inline
void MCFTPmssg::set_messagetype( MessageType messagetype ) 
{ 
   _messagetype = messagetype; 
}

inline
void MCFTPmssg::set_messagequal( MessageQual messagequal ) 
{ 
   _messagequal = messagequal; 
}

inline
void MCFTPmssg::set_request( MCFTPrequest& request ) { *_request = request; }

inline
void MCFTPmssg::set_quote( MCFTPquote& quote ) { *_quote = quote; }

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

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

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

inline
MCFTPheader* MCFTPmssg::header() { return _header; }

inline
MCFTPmssg::MessageType MCFTPmssg::messagetype() { return _messagetype; }

inline
MCFTPmssg::MessageQual MCFTPmssg::messagequal() { return _messagequal; }

inline
MCFTPrequest* MCFTPmssg::request() { return _request; }

inline
MCFTPquote* MCFTPmssg::quote() { return _quote; }

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

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

// ##### overloaded operators #####

inline bool operator > ( 
  MCFTPmssg::MessageType lhs, MCFTPmssg::MessageType rhs 
)
{
   return int(lhs) > int(rhs);
}

inline bool operator >= ( 
  MCFTPmssg::MessageType lhs, MCFTPmssg::MessageType rhs 
)
{
   return int(lhs) >= int(rhs);
}

inline bool operator < ( 
  MCFTPmssg::MessageType lhs, MCFTPmssg::MessageType rhs 
)
{
   return int(lhs) < int(rhs);
}

inline bool operator <= ( 
   MCFTPmssg::MessageType lhs, MCFTPmssg::MessageType rhs 
)
{
   return int(lhs) <= int(rhs);
}

inline
string MCFTPmssg::help( MessageType messagetype )
{
   switch(messagetype) {
      case MCFTPmssg::messagetype_unknown:
         return " ==> MCFTPmssg::messagetype_unknown ";
         break;
      case MCFTPmssg::messagetype_request:
         return " ==> MCFTPmssg::messagetype_request ";
         break;
      case MCFTPmssg::messagetype_quote:
         return " ==> MCFTPmssg::messagetype_quote ";
         break;
      case MCFTPmssg::messagetype_mrasb:
         return " ==> MCFTPmssg::messagetype_mrasb ";
         break;
   }
   return "";
}

inline
string MCFTPmssg::help( MessageQual messagequal )
{
   switch(messagequal) {
      case MCFTPmssg::messagequal_none:
         return " ==> MCFTPmssg::messagequal_none ";
         break;
      case MCFTPmssg::messagequal_error:
         return " ==> MCFTPmssg::messagequal_error ";
         break;
      case MCFTPmssg::messagequal_notfound:
         return " ==> MCFTPmssg::messagequal_notfound ";
         break;
      case MCFTPmssg::messagequal_quoteonly:
         return " ==> MCFTPmssg::messagequal_quoteonly ";
         break;
      case MCFTPmssg::messagequal_correction:
         return " ==> MCFTPmssg::messagequal_correction ";
         break;
   }
   return "";
}


#endif

---