MRAsbn.h

Go to the documentation of this file.

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

#ifndef MRASBN_H
#define MRASBN_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 MRAsbn
{
   public:

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

      MRAsbn& copy( const MRAsbn& );
      MRAsbn& operator = ( const MRAsbn& ); 
      MRAsbn& copy( int sbn );
      MRAsbn& operator = ( int sbn ); 

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

      int& operator [] ( int d );

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

      void report( ostream& os = cout );

      void set_dim(int);
      int dim();

      int sizeb();

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

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

   private:

      int _dim;
      int _n[MRA_MAXDIM];

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

};

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

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

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

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

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

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

inline
MRAsbn& MRAsbn::operator () ( const MRAsbn& sbn ) 
{ 
   return copy(sbn); 
}

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

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

inline
bool MRAsbn::is_equal( const MRAsbn& 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 MRAsbn::operator == ( const MRAsbn& rhs ) { return is_equal(rhs); }

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

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

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

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

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

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

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

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

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

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

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

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

inline
BufferBase& operator >> ( BufferBase& buffer, MRAsbn& sbn )
{
   sbn.write(buffer);
   return buffer;
}

inline
BufferBase& operator << ( BufferBase& buffer, MRAsbn& sbn )
{
   sbn.read(buffer);
   return buffer;
}

inline
istream& operator >> ( istream& is, MRAsbn& sbn )
{
   sbn.write(is);
   return is;
}

inline
ostream& operator << ( ostream& os, MRAsbn& sbn )
{
   sbn.read(os);
   return os;
}

#endif

---