MRAmpEncode.h

Go to the documentation of this file.

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

#ifndef MRAMPENCODE_H
#define MRAMPENCODE_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 MRAsbEncode;

class MRAmpEncode
{
   public:

      MRAmpEncode();
      MRAmpEncode( const MRAmpEncode& );
      MRAmpEncode(
         int grid_dim, int array_dim = 0,
         int bplen_mpsizeb = 0, int bplen_coef = 0,
         int bplen_n = 0, int bplen_a = 0
      );
      MRAmpEncode(
         int grid_dim, int array_dim,
         int bplen_mpsizeb, int bplen_coef,
         const int* bplen_n, const int* bplen_a
      );

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

      MRAmpEncode& operator () ();
      MRAmpEncode& operator () ( const MRAmpEncode& );
      MRAmpEncode& operator () (
         int grid_dim, int array_dim = 0,
         int bplen_mpsizeb = 0, int bplen_coef = 0,
         int bplen_n = 0, int bplen_a = 0
      );
      MRAmpEncode& operator () (
         int grid_dim, int array_dim,
         int bplen_mpsizeb, int bplen_coef,
         const int* bplen_n, const int* bplen_a
      );

      bool is_equal( const MRAmpEncode& );
      bool operator == ( const MRAmpEncode& );
      bool operator != ( const MRAmpEncode& );

      MRAmpEncode& set_null();
      bool is_null();
      bool operator ! ();

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

      void write( istream& );
      MRAmpEncode& operator << ( istream& );
      void read( ostream& );
      MRAmpEncode& operator >> ( ostream& );

      int grid_dim();
      int array_dim();
      int bplen_mpsizeb();
      int bplen_coef();
      int* bplen_n();
      int bplen_n( int d );
      int* bplen_a();
      int bplen_a( int d );

      virtual int sizeb();

      void report( ostream& = cout );

   protected:

      int _grid_dim;
      int _array_dim;
      int _bplen_mpsizeb;
      int _bplen_coef;
      int _bplen_n[MRA_MAXDIM];
      int _bplen_a[MRA_MAXDIM];

   private:
      void synchronize() {}

   friend class MRAsbEncode; 

   friend BufferBase& operator << ( BufferBase&, MRAmpEncode& );

   friend BufferBase& operator >> ( BufferBase&, MRAmpEncode& );

   friend ostream& operator << ( ostream&, MRAmpEncode& );

   friend istream& operator >> ( istream&, MRAmpEncode& );

};

inline
MRAmpEncode::MRAmpEncode() { set_null(); } 

inline
MRAmpEncode::MRAmpEncode( const MRAmpEncode& mpenc )
  : _grid_dim(mpenc._grid_dim), _array_dim(mpenc._array_dim), 
    _bplen_mpsizeb(mpenc._bplen_mpsizeb), _bplen_coef(mpenc._bplen_coef)
{
   for( int d = 0; d < _grid_dim; ++d ) _bplen_n[d] = mpenc._bplen_n[d];
   for( int d = 0; d < _array_dim; ++d ) _bplen_a[d] = mpenc._bplen_a[d];
}

inline
MRAmpEncode::MRAmpEncode(
  int grid_dim, int array_dim,
  int bplen_mpsizeb, int bplen_coef,
  int bplen_n, int bplen_a
)
  : _grid_dim(grid_dim), _array_dim(array_dim), 
    _bplen_mpsizeb(bplen_mpsizeb), _bplen_coef(bplen_coef)
{
   for( int d = 0; d < _grid_dim; ++d ) _bplen_n[d] = bplen_n;
   for( int d = 0; d < _array_dim; ++d ) _bplen_a[d] = bplen_a;
}

inline
MRAmpEncode::MRAmpEncode(
  int grid_dim, int array_dim,
  int bplen_mpsizeb, int bplen_coef,
  const int* bplen_n, const int* bplen_a
)
  : _grid_dim(grid_dim), _array_dim(array_dim), 
    _bplen_mpsizeb(bplen_mpsizeb), _bplen_coef(bplen_coef)
{
   for( int d = 0; d < _grid_dim; ++d ) _bplen_n[d] = bplen_n[d];
   for( int d = 0; d < _array_dim; ++d ) _bplen_a[d] = bplen_a[d];
}

inline
MRAmpEncode& MRAmpEncode::copy( const MRAmpEncode& mpenc )
{
   if ( this != &mpenc ) {
      _grid_dim = mpenc._grid_dim;
      _array_dim = mpenc._array_dim;
      _bplen_mpsizeb = mpenc._bplen_mpsizeb;
      _bplen_coef = mpenc._bplen_coef;
      for( int d = 0; d < _grid_dim; ++d ) _bplen_n[d] = mpenc._bplen_n[d];
      for( int d = 0; d < _array_dim; ++d ) _bplen_a[d] = mpenc._bplen_a[d];
   }
   return *this;
}

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

inline
MRAmpEncode& MRAmpEncode::operator () () { return set_null(); }

inline
MRAmpEncode& MRAmpEncode::operator () ( const MRAmpEncode& mpenc )
{ 
   return copy(mpenc);
}

inline
MRAmpEncode& MRAmpEncode::operator () (
  int grid_dim, int array_dim,
  int bplen_mpsizeb, int bplen_coef,
  int bplen_n, int bplen_a
)
{
   _grid_dim = grid_dim;
   _array_dim = array_dim;
   _bplen_mpsizeb = bplen_mpsizeb;
   _bplen_coef = bplen_coef;
   for( int d = 0; d < _grid_dim; ++d ) _bplen_n[d] = bplen_n;
   for( int d = 0; d < _array_dim; ++d ) _bplen_a[d] = bplen_a;
   return *this;
}

inline
MRAmpEncode& MRAmpEncode::operator () (
  int grid_dim, int array_dim,
  int bplen_mpsizeb, int bplen_coef,
  const int* bplen_n, const int* bplen_a
)
{
   _grid_dim = grid_dim;
   _array_dim = array_dim;
   _bplen_mpsizeb = bplen_mpsizeb;
   _bplen_coef = bplen_coef;
   for( int d = 0; d < _grid_dim; ++d ) _bplen_n[d] = bplen_n[d];
   for( int d = 0; d < _array_dim; ++d ) _bplen_a[d] = bplen_a[d];
   return *this;
}

inline
bool MRAmpEncode::is_equal( 
  const MRAmpEncode& mpenc
)
{
   if ( this != &mpenc ) {
      if ( _grid_dim != mpenc._grid_dim ) return false;
      if ( _array_dim != mpenc._array_dim ) return false;
      if ( _bplen_mpsizeb != mpenc._bplen_mpsizeb ) return false;
      if ( _bplen_coef != mpenc._bplen_coef ) return false;
      for( int d = 0; d < _grid_dim; ++d ) 
         if ( _bplen_n[d] != mpenc._bplen_n[d] ) return false;
      for( int d = 0; d < _array_dim; ++d ) 
         if ( _bplen_a[d] != mpenc._bplen_a[d] ) return false;
   } 
   return true;
}

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

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

inline
MRAmpEncode& MRAmpEncode::set_null() 
{
   _grid_dim = 0;
   _array_dim = 0;
   _bplen_mpsizeb = 0;
   _bplen_coef = 0;
   return *this;
}

inline
bool MRAmpEncode::is_null() { return ( _grid_dim == 0); }

inline
bool MRAmpEncode::operator ! () { return is_null(); }

inline
void MRAmpEncode::write( BufferBase& buffer )
{
   bytepack bp;
   buffer >> bp(0,1); _grid_dim = int(bp);
   buffer >> bp(0,1); _array_dim = int(bp);
   buffer >> bp(0,1); _bplen_mpsizeb = int(bp);
   buffer >> bp(0,1); _bplen_coef = int(bp);
   for( int d = 0; d < _grid_dim; ++d ) {
      buffer >> bp(0,1); _bplen_n[d]= int(bp);
   }
   for( int d = 0; d < _array_dim; ++d ) {
      buffer >> bp(0,1); _bplen_a[d]= int(bp);
   }
   synchronize();
}

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

inline
void MRAmpEncode::read( BufferBase& buffer )
{
   bytepack bp;
   buffer << bp( _grid_dim, 1 );
   buffer << bp( _array_dim, 1 );
   buffer << bp( _bplen_mpsizeb, 1 );
   buffer << bp( _bplen_coef, 1 );
   for( int d = 0; d < _grid_dim; ++d ) {
      buffer << bp( _bplen_n[d], 1 );
   }
   for( int d = 0; d < _array_dim; ++d ) {
      buffer << bp( _bplen_a[d], 1 );
   }
}

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

inline
void MRAmpEncode::write( istream& is )
{
   bytepack bp;
   is >> bp(0,1); _grid_dim = int(bp);
   is >> bp(0,1); _array_dim = int(bp);
   is >> bp(0,1); _bplen_mpsizeb = int(bp);
   is >> bp(0,1); _bplen_coef = int(bp);
   for( int d = 0; d < _grid_dim; ++d ) {
      is >> bp(0,1); _bplen_n[d]= int(bp);
   }
   for( int d = 0; d < _array_dim; ++d ) {
      is >> bp(0,1); _bplen_a[d]= int(bp);
   }
   synchronize();
}

inline
MRAmpEncode& MRAmpEncode::operator << ( istream& is ) 
{
   write(is);
   return *this;
}

inline
void MRAmpEncode::read( ostream& os )
{
   bytepack bp;
   os << bp( _grid_dim, 1 );
   os << bp( _array_dim, 1 );
   os << bp( _bplen_mpsizeb, 1 );
   os << bp( _bplen_coef, 1 );
   for( int d = 0; d < _grid_dim; ++d ) {
      os << bp( _bplen_n[d], 1 );
   }
   for( int d = 0; d < _array_dim; ++d ) {
      os << bp( _bplen_a[d], 1 );
   }
}

inline
MRAmpEncode& MRAmpEncode::operator >> ( ostream& os ) 
{
   read(os);
   return *this;
}

inline
int MRAmpEncode::grid_dim() { return _grid_dim; }

inline
int MRAmpEncode::array_dim() { return _array_dim; }

inline
int MRAmpEncode::bplen_mpsizeb() { return _bplen_mpsizeb; }

inline
int MRAmpEncode::bplen_coef() { return _bplen_coef; }

inline
int MRAmpEncode::bplen_n( int d ) { return _bplen_n[d]; }

inline
int MRAmpEncode::bplen_a( int d ) { return _bplen_a[d]; }

inline
int MRAmpEncode::sizeb() { return ( 4 + grid_dim() + array_dim() ); }

inline
void MRAmpEncode::report( ostream& os ) 
{
   os << "MRAmpEncode::report grid_dim=" << grid_dim() << '\n';
   os << "MRAmpEncode::report array_dim=" << array_dim() << '\n';
   os << "MRAmpEncode::report bplen_mpsizeb=" 
      << bplen_mpsizeb() << '\n';
   os << "MRAmpEncode::report bplen_coef=" << bplen_coef() << '\n';
   for( int d = 0; d < _grid_dim; ++d ) {
      os << "MRAmpEncode::report bplen_n[" << d << "]=" 
         << bplen_n(d) << '\n';
   }
   for( int d = 0; d < _array_dim; ++d ) {
      os << "MRAmpEncode::report bplen_a[" << d << "]=" 
         << bplen_a(d) << '\n';
   }
}

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

inline
BufferBase& operator << ( BufferBase& buffer, MRAmpEncode& mp )
{
   mp.read(buffer);
   return buffer;
}

inline
BufferBase& operator >> ( BufferBase& buffer, MRAmpEncode& mp )
{
   mp.write(buffer);
   return buffer;
}

inline
ostream& operator << ( ostream& os, MRAmpEncode& mp )
{
   mp.read(os);
   return os;
}

inline
istream& operator >> ( istream& is, MRAmpEncode& mp )
{
   mp.write(is);
   return is;
}

#endif

---