MRAmspec.h

Go to the documentation of this file.

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

#ifndef MRAMSPEC_H
#define MRAMSPEC_H

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

#include "BufferBase.h"
#include "MRAmlevel.h"
#include "MRAmrange.h"

class MRAmspec { 

   public: 

      MRAmrange mthis, mexist, mtheory;

      MRAmspec( const MRAmspec& );
      MRAmspec( int dim = 0 );
      MRAmspec( 
        const MRAmrange& mthis, 
        const MRAmrange& mexist, 
        const MRAmrange& mtheory 
      );
      
      MRAmspec& operator () ( const MRAmspec& );
      MRAmspec& operator () ( int dim = 0 );
      MRAmspec& operator () ( 
        const MRAmrange& mthis, 
        const MRAmrange& mexist,
        const MRAmrange& mtheory 
      );

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

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

      void set_dim(int);
      int dim();

      int sizeb();

      void report( ostream& os = cout );

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

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

   protected:
      int _dim;

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

};

inline
MRAmspec::MRAmspec( const MRAmspec& mspec ) 
  : mthis(mspec.mthis), mexist(mspec.mexist), mtheory(mspec.mtheory),
    _dim(mspec._dim)
{}

inline
MRAmspec::MRAmspec( int dim ) 
  : mthis(dim), mexist(dim), mtheory(dim), 
    _dim(dim)
{}

inline
MRAmspec::MRAmspec( 
  const MRAmrange& mthis0, const MRAmrange& mexist0, const MRAmrange& mtheory0
) : mthis(mthis0), mexist(mexist0), mtheory(mtheory0)
{
   _dim = mthis.dim();
}

inline
MRAmspec& MRAmspec::copy( const MRAmspec& mspec ) 
{
   mthis = mspec.mthis;
   mexist = mspec.mexist;
   mtheory = mspec.mtheory;
   _dim = mspec._dim;
   return *this;
}

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

inline
MRAmspec& MRAmspec::operator () ( const MRAmspec& mspec ) 
{ 
   mthis = mspec.mthis; 
   mexist = mspec.mexist; 
   mtheory = mspec.mtheory; 
   _dim = mspec._dim;
   return *this;
}

inline
MRAmspec& MRAmspec::operator () ( int dim ) 
{ 
   mthis(dim); 
   mexist(dim); 
   mtheory(dim); 
   _dim = dim;
   return *this; 
}

inline
MRAmspec& MRAmspec::operator () ( 
  const MRAmrange& mthis0, const MRAmrange& mexist0, const MRAmrange& mtheory0
) 
{ 
   mthis = mthis0;
   mexist = mexist0;
   mtheory = mtheory0;
   _dim = mthis.dim();
   return *this;
}

inline
bool MRAmspec::is_equal( const MRAmspec& mspec ) 
{
   if ( mthis != mspec.mthis ) return false;
   if ( mexist != mspec.mexist ) return false;
   if ( mtheory != mspec.mtheory ) return false;
   if ( _dim != mspec._dim ) return false;
   return true;
}

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

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

inline
void MRAmspec::set_dim( int dim ) 
{ 
   mthis(dim);
   mexist(dim);
   mtheory(dim);
   _dim = dim;
}

inline
int MRAmspec::dim() { return _dim; }

inline
int MRAmspec::sizeb() { return mthis.sizeb() +mexist.sizeb() +mtheory.sizeb();}

inline
void MRAmspec::report( ostream& os ) {
   os << "MRAmspec::report(){\n";
   os << "mthis =\n";
   mthis.report();
   os << "mexist =\n";
   mexist.report();
   os << "mtheory =\n";
   mtheory.report();
   os << "dim = " << _dim << endl;
   os << "}\n";
}

inline
void MRAmspec::write( BufferBase& buffer )
{
   buffer >> mthis;
   buffer >> mexist;
   buffer >> mtheory;
}

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

inline
void MRAmspec::read( BufferBase& buffer )
{
   buffer << mthis;
   buffer << mexist;
   buffer << mtheory;
}

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

inline
void MRAmspec::write( istream& is )
{
   is >> mthis;
   is >> mexist;
   is >> mtheory;
}

inline
void MRAmspec::read( ostream& os )
{
   os << mthis;
   os << mexist;
   os << mtheory;
}


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

inline
BufferBase& operator >> ( BufferBase& buffer, MRAmspec& mspec )
{
   mspec.write(buffer);
   return buffer;
}

inline
BufferBase& operator << ( BufferBase& buffer, MRAmspec& mspec )
{
   mspec.read(buffer);
   return buffer;
}

inline
istream& operator >> ( istream& is, MRAmspec& mspec )
{
   mspec.write(is);
   return is;
}

inline
ostream& operator << ( ostream& os, MRAmspec& mspec )
{
   mspec.read(os);
   return os;
}

#endif

---