MCFTPquote.cpp

Go to the documentation of this file.

// MCFTPquote.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 "MRAmspec.h"
#include "MRAcspec.h"
#include "MCFTPrequest.h"

#include "MCFTPquote.h"

MCFTPquote::MCFTPquote( int grid_dim, int array_dim )
  : _grid_dim(grid_dim), _array_dim(array_dim),
    _name("")
{
   _sbn(_grid_dim);
   _mspec(_grid_dim);
}

MCFTPquote::MCFTPquote( const MCFTPquote& quote )
{
   _grid_dim = quote._grid_dim;
   _array_dim = quote._array_dim;
   _name = quote._name;
   _sbn = quote._sbn;
   _mspec = quote._mspec;
   _cspec = quote._cspec;
}

MCFTPquote::MCFTPquote( const MCFTPrequest& request )
{
   _grid_dim = request._grid_dim;
   _array_dim = request._array_dim;
   _name = request._name;
   _sbn = request._sbn;
   _mspec = request._mspec;
   _cspec = request._cspec;
}

MCFTPquote& MCFTPquote::operator () ()
{
   _grid_dim = 0;
   _array_dim = 0;
   _name = "";
   _sbn(0);
   _mspec(0);
   return *this;
}

MCFTPquote& MCFTPquote::operator () ( int grid_dim, int array_dim )
{
   _grid_dim = grid_dim;
   _array_dim = array_dim;
   _name = "";
   _sbn(_grid_dim) = 0;
   _mspec(_grid_dim);
   return *this;
}

MCFTPquote& MCFTPquote::operator () ( const MCFTPrequest& request )
{
   _grid_dim = request._grid_dim;
   _array_dim = request._array_dim;
   _name = request._name;
   _sbn(_grid_dim) = request._sbn;
   _mspec(_grid_dim) = request._mspec;
   _cspec = request._cspec;
   return *this;
}

MCFTPquote& MCFTPquote::operator () ( const MCFTPquote& quote )
{
   _grid_dim = quote._grid_dim;
   _array_dim = quote._array_dim;
   _sbn( _grid_dim ) = quote._sbn;
   _mspec(_grid_dim) = quote._mspec;
   _cspec = quote._cspec;
   return *this;
}

MCFTPquote& MCFTPquote::copy( const MCFTPquote& quote )
{
   if ( this != &quote ) {
      _grid_dim = quote._grid_dim;
      _array_dim = quote._array_dim;
      _name = quote._name;
      _sbn( _grid_dim ) = quote._sbn;
      _mspec(_grid_dim) = quote._mspec;
      _cspec = quote._cspec;
   }
   return *this;
}

MCFTPquote& MCFTPquote::copy( const MCFTPrequest& rhs )
{
   _grid_dim = rhs._grid_dim;
   _array_dim = rhs._array_dim;
   _name = rhs._name;
   _sbn(_grid_dim) = rhs._sbn;
   _mspec(_grid_dim) = rhs._mspec;
   _cspec = rhs._cspec;
   return *this;
}

bool MCFTPquote::is_equal( const MCFTPquote& quote )
{
   if ( this != &quote ) {
      if ( _grid_dim != quote._grid_dim ) return false;
      if ( _array_dim != quote._array_dim ) return false;
      if ( _name != quote._name ) return false;
      if ( _sbn != quote._sbn ) return false;
      if ( _mspec != quote._mspec ) return false;
      if ( _cspec != quote._cspec ) return false;
   }
   return true;
}

bool MCFTPquote::is_equal( const MCFTPrequest& request )
{
   if ( _grid_dim != request._grid_dim ) return false;
   if ( _array_dim != request._array_dim ) return false;
   if ( _name != request._name ) return false;
   if ( _sbn != request._sbn ) return false;
   if ( _mspec != request._mspec ) return false;
   if ( _cspec != request._cspec ) return false;
   return true;
}

void MCFTPquote::write( BufferBase& buffer )
{
   bytepack bp;
   buffer >> bp( 0, 1 ); _grid_dim = int(bp);
   buffer >> bp( 0, 1 ); _array_dim = int(bp);
   buffer >> bp( 0, 1 ); int namesize = int(bp);
   _name = "";
   for( int i = 0; i < namesize; ++i ) _name += buffer.get();
   _sbn(_grid_dim);
   buffer >> _sbn;
   _mspec(_grid_dim);
   buffer >> _mspec;
   buffer >> _cspec;
}

void MCFTPquote::read( BufferBase& buffer )
{
   bytepack bp;
   buffer << bp( _grid_dim, 1 );
   buffer << bp( _array_dim, 1 );
   buffer << bp( int(_name.size()), 1 );
   for(unsigned int i = 0; i < _name.size(); ++i ) buffer.put( _name[i] );
   buffer << _sbn;
   buffer << _mspec;
   buffer << _cspec;
}

void MCFTPquote::write( istream& is )
{
   bytepack bp;
   is >> bp( 0, 1 ); _grid_dim = int(bp);
   is >> bp( 0, 1 ); _array_dim = int(bp);
   is >> bp( 0, 1 ); int namesize = int(bp);
   _name = "";
   for( int i = 0; i < namesize; ++i ) _name += is.get();
   _sbn(_grid_dim);
   is >> _sbn;
   _mspec(_grid_dim);
   is >> _mspec;
   is >> _cspec;
}

void MCFTPquote::read( ostream& os )

{
   bytepack bp;
   os << bp( _grid_dim, 1 );
   os << bp( _array_dim, 1 );
   os << bp( int(_name.size()), 1 );
   for(unsigned int i = 0; i < _name.size(); ++i ) os.put( _name[i] );
   os << _sbn;
   os << _mspec;
   os << _cspec;
}

int MCFTPquote::sizeb() 
{ 
   return 3 + _name.size() + _sbn.sizeb() + _mspec.sizeb() + _cspec.sizeb();
}

void MCFTPquote::report( ostream& os ) 
{
   os << "MCFTPquote::report(){\n";
   os << "grid_dim = " << _grid_dim << '\n';
   os << "array_dim = " << _array_dim << '\n';
   os << "name.size() = " << _name.size() << '\n';
   os << "name = " << _name << '\n';
   os << "sbn =\n";
   _sbn.report(os);
   os << "mspec =\n";
   _mspec.report(os);
   os << "cspec =\n";
   _cspec.report(os);
   os << "}\n";
}
// ##### friends #####

BufferBase& operator << ( BufferBase& buffer, MCFTPquote& quote )
{
   quote.read(buffer);
   return buffer;
}

BufferBase& operator >> ( BufferBase& buffer, MCFTPquote& quote )
{
   quote.write(buffer);
   return buffer;
}

ostream& operator << ( ostream& os, MCFTPquote& quote )
{
   quote.read(os);
   return os;
}

istream& operator >> ( istream& is, MCFTPquote& quote )
{
   quote.write(is);
   return is;
}

---