MRAclevel.h

Go to the documentation of this file.

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

#ifndef MRACLEVEL_H
#define MRACLEVEL_H

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

#include "BufferBase.h"

#ifndef MRA_MAXDIM
#define MRA_MAXDIM 4
#endif

class MRAclevel
{
   public:

      static const int cmin_limit = -16;
      static const int cmax_limit = 15;

      MRAclevel();
      MRAclevel( const MRAclevel& );

      MRAclevel& operator () ( const MRAclevel& );

      MRAclevel& copy( const MRAclevel& );
      MRAclevel& operator = ( const MRAclevel& ); 
      MRAclevel& copy( int c );
      MRAclevel& operator = ( int c );

      operator int();

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

      MRAclevel operator + ( int );
      MRAclevel& operator += ( int );

      MRAclevel operator - ( int );
      MRAclevel& operator -= ( int );

      int sizeb();

      void report( ostream& os = cout );

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

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

   protected:

      int _c;

   friend class MRAcrange;

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

};

inline
MRAclevel::MRAclevel() : _c(0) {}

inline
MRAclevel::MRAclevel( const MRAclevel& clevel ) : _c(clevel._c) {}

inline
MRAclevel& MRAclevel::operator () ( const MRAclevel& clevel ) 
{ 
   return copy(clevel); 
}

inline
MRAclevel& MRAclevel::copy( const MRAclevel& clevel ) 
{
   _c = clevel._c;
   return *this;
}

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

inline
MRAclevel& MRAclevel::copy( int c ) 
{
   _c = c;
   return *this;
}

inline
MRAclevel& MRAclevel::operator = ( int rhs ) { return copy(rhs); }

inline
MRAclevel::operator int () { return _c; }

inline
bool MRAclevel::is_equal( const MRAclevel& rhs ) 
{
   return _c == rhs._c;
}

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

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

inline
MRAclevel MRAclevel::operator + ( int c )
{
   MRAclevel clevel(*this);
   clevel += c;
   return clevel;
}

inline
MRAclevel& MRAclevel::operator += ( int c )
{
   _c += c;
   return *this;
}

inline
MRAclevel MRAclevel::operator - ( int c )
{
   MRAclevel clevel(*this);
   clevel -= c;
   return clevel;
}

inline
MRAclevel& MRAclevel::operator -= ( int c )
{
   _c -= c;
   return *this;
}

inline
int MRAclevel::sizeb() { return 1; }

inline
void MRAclevel::report( ostream& os ) {
   os << "MRAclevel::report(){\n";
   os << "c = " << _c << '\n';
   os << "}\n";
}

inline
void MRAclevel::write( BufferBase& buffer )
{
   bytepack bp;
   buffer >> bp( 0, 1 ); _c = int(bp);
}

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

inline
void MRAclevel::read( BufferBase& buffer )
{
   bytepack bp;
   buffer << bp( _c, 1 );
}

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

inline
void MRAclevel::write( istream& is )
{
   bytepack bp;
   is >> bp( 0, 1 ); _c = int(bp);
}

inline
void MRAclevel::read( ostream& os )
{
   bytepack bp;
   os << bp( _c, 1 );
}

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

inline
BufferBase& operator >> ( BufferBase& buffer, MRAclevel& clevel )
{
   clevel.write(buffer);
   return buffer;
}

inline
BufferBase& operator << ( BufferBase& buffer, MRAclevel& clevel )
{
   clevel.read(buffer);
   return buffer;
}

inline
istream& operator >> ( istream& is, MRAclevel& clevel )
{
   clevel.write(is);
   return is;
}

inline
ostream& operator << ( ostream& os, MRAclevel& clevel )
{
   clevel.read(os);
   return os;
}

#endif

---