MRAcspec.h

Go to the documentation of this file.

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

#ifndef MRACSPEC_H
#define MRACSPEC_H

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

#include "BufferBase.h"
#include "MRAclevel.h"
#include "MRAcrange.h"

class MRAcspec { 

   public: 

      MRAcrange cthis, cexist, ctheory;
      
      MRAcspec() {}

      MRAcspec( const MRAcspec& );
      
      MRAcspec& operator () ( const MRAcspec& );

      MRAcspec& copy( const MRAcspec& );
      MRAcspec& operator = ( const MRAcspec& );

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

      int sizeb();

      void report( ostream& os = cout );

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

      void write( istream& );
      void read( ostream& );

   friend BufferBase& operator << ( BufferBase&, MRAcspec& );
   friend BufferBase& operator >> ( BufferBase&, MRAcspec& );
   friend ostream& operator << ( ostream&, MRAcspec& );
   friend istream& operator >> ( istream&, MRAcspec& );

};

inline
MRAcspec::MRAcspec( const MRAcspec& cspec ) 
  : cthis(cspec.cthis), cexist(cspec.cexist), ctheory(cspec.ctheory)
{}

inline
MRAcspec& MRAcspec::operator () ( const MRAcspec& cspec ) 
{ 
   cthis = cspec.cthis; 
   cexist = cspec.cexist; 
   ctheory = cspec.ctheory; 
   return *this;
}

inline
MRAcspec& MRAcspec::copy( const MRAcspec& cspec ) 
{
   cthis = cspec.cthis;
   cexist = cspec.cexist;
   ctheory = cspec.ctheory;
   return *this;
}

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

inline
bool MRAcspec::is_equal( const MRAcspec& cspec ) 
{
   if ( cthis.cmin != cspec.cthis.cmin ) return false;
   if ( cthis.cmax != cspec.cthis.cmax ) return false;
   if ( cexist.cmin != cspec.cexist.cmin ) return false;
   if ( cexist.cmax != cspec.cexist.cmax ) return false;
   if ( ctheory.cmin != cspec.ctheory.cmin ) return false;
   if ( ctheory.cmax != cspec.ctheory.cmax ) return false;
   return true;
}

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

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

inline 
int MRAcspec::sizeb() { return cthis.sizeb() +cexist.sizeb() +ctheory.sizeb();}

inline
void MRAcspec::report( ostream& os ) {
   os << "MRAcspec::report(){\n";
   os << "cthis =\n";
   cthis.report();
   os << "cexist =\n";
   cexist.report();
   os << "ctheory =\n";
   ctheory.report();
   os << "}\n";
}

inline
void MRAcspec::write( BufferBase& buffer )
{
//   bytepack bp;
//   buffer >> bp( 0, 1 ); cthis.cmin = int(bp);
//   buffer >> bp( 0, 1 ); cthis.cmax = int(bp);
//   buffer >> bp( 0, 1 ); cexist.cmin = int(bp);
//   buffer >> bp( 0, 1 ); cexist.cmax = int(bp);
//   buffer >> bp( 0, 1 ); ctheory.cmin = int(bp);
//   buffer >> bp( 0, 1 ); ctheory.cmax = int(bp);
   buffer >> cthis;
   buffer >> cexist;
   buffer >> ctheory;
}

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

inline
void MRAcspec::read( BufferBase& buffer )
{
//   bytepack bp;
//   buffer << bp( cthis.cmin, 1 );
//   buffer << bp( cthis.cmin, 1 );
//   buffer << bp( cexist.cmin, 1 );
//   buffer << bp( cexist.cmin, 1 );
//   buffer << bp( ctheory.cmin, 1 );
//   buffer << bp( ctheory.cmin, 1 );
   buffer << cthis;
   buffer << cexist;
   buffer << ctheory;
}

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

inline
void MRAcspec::write( istream& is )
{
//   bytepack bp;
//   is >> bp( 0, 1 ); cthis.cmin = int(bp);
//   is >> bp( 0, 1 ); cthis.cmax = int(bp);
//   is >> bp( 0, 1 ); cexist.cmin = int(bp);
//   is >> bp( 0, 1 ); cexist.cmax = int(bp);
//   is >> bp( 0, 1 ); ctheory.cmin = int(bp);
//   is >> bp( 0, 1 ); ctheory.cmax = int(bp);
   is >> cthis;
   is >> cexist;
   is >> ctheory;
}

inline
void MRAcspec::read( ostream& os )
{
//   bytepack bp;
//   os << bp( cthis.cmin, 1 );
//   os << bp( cthis.cmin, 1 );
//   os << bp( cexist.cmin, 1 );
//   os << bp( cexist.cmin, 1 );
//   os << bp( ctheory.cmin, 1 );
//   os << bp( ctheory.cmin, 1 );
   os << cthis;
   os << cexist;
   os << ctheory;
}


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

inline
BufferBase& operator >> ( BufferBase& buffer, MRAcspec& cspec )
{
   cspec.write(buffer);
   return buffer;
}

inline
BufferBase& operator << ( BufferBase& buffer, MRAcspec& cspec )
{
   cspec.read(buffer);
   return buffer;
}

inline
istream& operator >> ( istream& is, MRAcspec& cspec )
{
   cspec.write(is);
   return is;
}

inline
ostream& operator << ( ostream& os, MRAcspec& cspec )
{
   cspec.read(os);
   return os;
}

#endif

---