MRAsize.h

Go to the documentation of this file.

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

#ifndef _MRASIZE_H
#define _MRASIZE_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 MRAsize
{
   public:

      MRAsize( const MRAsize& );
      explicit MRAsize( int dim = 0 );

      MRAsize& copy( const MRAsize& );
      MRAsize& operator = ( const MRAsize& ); 
      MRAsize& copy( int size );
      MRAsize& operator = ( int size ); 

      MRAsize& operator () ( const MRAsize& );
      MRAsize& operator () ( int dim = 0 );

      int& operator [] ( int d );

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

      void report( ostream& os = cout );

      void set_dim(int);
      int dim();

      int sizeb();

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

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

   private:

      int _dim;
      int _n[MRA_MAXDIM];

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

};

inline
MRAsize::MRAsize( int dim ) : _dim(dim) {}

inline
MRAsize::MRAsize( const MRAsize& size ) 
  : _dim(size._dim)
{
   for( int d = 0; d < _dim; ++d ) _n[d] = size._n[d];
}

inline
MRAsize& MRAsize::copy( const MRAsize& size ) 
{
   _dim = size._dim;
   for( int d = 0; d < _dim; ++d ) _n[d] = size._n[d];
   return *this;
}

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

inline
MRAsize& MRAsize::copy( int size ) 
{
   for( int d = 0; d < _dim; ++d ) _n[d] = size;
   return *this;
}

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

inline
MRAsize& MRAsize::operator () ( const MRAsize& size ) 
{ 
   return copy(size); 
}

inline
MRAsize& MRAsize::operator () ( int dim ) 
{ 
   _dim = dim;
   return *this;
}

inline
int& MRAsize::operator [] ( int d ) { return _n[d]; }

inline
bool MRAsize::is_equal( const MRAsize& rhs ) 
{
   if ( _dim != rhs._dim ) return false;
   for( int d = 0; d < _dim; ++d ) 
      if ( _n[d] != rhs._n[d] ) return false;
   return true;
}

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

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

inline
void MRAsize::report( ostream& os ) {
   os << "MRAsize::report(){\n";
   os << "dim = " << _dim << '\n';
   for( int d = 0; d < _dim; ++d ) { os << "n[] = " << _n[d] << '\n'; }
   os << "}\n";
}

inline
void MRAsize::set_dim( int dim ) { _dim = dim; }

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

inline
int MRAsize::sizeb() { return _dim * 4; }

inline
void MRAsize::write( BufferBase& buffer )
{
   bytepack bp;
   for( int d = 0; d < _dim; ++d ) {
      buffer >> bp( 0, 4 ); _n[d] = int(bp);
   }
}

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

inline
void MRAsize::read( BufferBase& buffer )
{
   bytepack bp;
   for( int d = 0; d < _dim; ++d ) buffer << bp( _n[d], 4 );
}

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

inline
void MRAsize::write( istream& is )
{
   bytepack bp;
   for( int d = 0; d < _dim; ++d ) {
      is >> bp( 0, 4 ); _n[d] = int(bp);
   }
}

inline
void MRAsize::read( ostream& os )
{
   bytepack bp;
   for( int d = 0; d < _dim; ++d ) os << bp( _n[d], 4 );
}

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

inline
BufferBase& operator >> ( BufferBase& buffer, MRAsize& size )
{
   size.write(buffer);
   return buffer;
}

inline
BufferBase& operator << ( BufferBase& buffer, MRAsize& size )
{
   size.read(buffer);
   return buffer;
}

inline
istream& operator >> ( istream& is, MRAsize& size )
{
   size.write(is);
   return is;
}

inline
ostream& operator << ( ostream& os, MRAsize& size )
{
   size.read(os);
   return os;
}

#endif

---