MRAmpBase.h

Go to the documentation of this file.

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

#ifndef MRAMPBASE_H
#define MRAMPBASE_H

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

#include "BufferBase.h"
#include "MRAmpEncode.h"
#include "MRAacoef.h"

inline int mcode_to_m( const char mcode )
{
   return int( (unsigned char)( 0x1F & mcode ) );
}

inline int mcode_to_sw( const char mcode )
{
   return int( (unsigned char)( ( 0x80 & mcode ) >> 7 ) );
}

inline int mcode_to_rs( const char mcode )
{
   return int( (unsigned char)( ( 0x40 & mcode ) >> 6 ) );
}

inline int mcode_to_order( const char mcode )
{
   return int( (unsigned char)( ( 0x20 & mcode ) >> 5 ) );
}

#ifndef MRA_MAXDIM
#define MRA_MAXDIM 4
#endif

class MRAmpBase
{
   public:

      virtual string isa() const { return "MRAmpBase"; }

      static const int     goodbit = 0x01;
      static const int     failbit = 0x02;
      static const int   baddimbit = 0x04;
//      static const int    = 0x08; // not used
      static const int hdrfixedbit = 0x10;
      static const int  mpfixedbit = 0x20;

      MRAmpBase( BufferBase* );
      MRAmpBase( const MRAmpBase&, BufferBase* );
      MRAmpBase( const MRAmpEncode&, BufferBase* );

      virtual ~MRAmpBase();

      virtual MRAmpBase& copy( const MRAmpBase& );
      virtual MRAmpBase& operator = ( const MRAmpBase& );

      MRAmpBase& operator () ();
      MRAmpBase& operator () ( const MRAmpBase& rhs );
      MRAmpBase& operator () ( const MRAmpEncode& mpenc );

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

      void clear();
      void setstate(int);
      void clrstate(int);
      int rdstate( int = 0xFF );
      bool good();
      bool fail();
      bool baddim();
      bool hdrfixed();
      bool mpfixed();

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

      MRAmpBase& set_empty();
      bool is_empty();

      void fix_hdr();
      void refix_hdr();
      void fix_mp();
      void unfix_mp();

      void set_mcode( const char* mcode );
      void set_mcode( int d, char mcode );
      void set_n( const int* n );
      void set_n( int d, int n );

//      void append( int a, const Data_t coef );
//      void append( const int* a, const Data_t coef );
      void append( int a, bytepack bpcoef );
      void append( const int* a, bytepack bpcoef );

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

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

      MRAmpEncode& mpenc();

      int mpsizeb();
      int mcode( int d = 0 );
      int n( int d = 0 );

      int hdrsizeb();
      int acoefsizeb();
      int nullsizeb();

      int mcode_to_m( int = 0 );
      int mcode_to_sw( int = 0 );
      int mcode_to_rs( int = 0 );
      int mcode_to_order( int = 0 );

      void report( ostream& = cout );

      class iterator
      {
         public:
            iterator( MRAmpBase* );
            ~iterator();
            iterator& operator ++ ();
            MRAacoef operator * ();
            void set_null();
            bool is_null();
            bool operator ! ();
            operator bool();
            bool is_equal( const iterator& );
            bool operator == ( const iterator& );
            bool operator != ( const iterator& );
            bool operator < ( const iterator& );
            bool operator > ( const iterator& );
            bool operator <= ( const iterator& );
            bool operator >= ( const iterator& );
            int pos() { return _pos; }
         protected:
            int _pos;
            MRAmpBase* _ptmp;
         private:
            iterator() {}
         friend class MRAmpBase;
      };

      iterator begin();

      iterator end();

   protected:
      int _state;

      MRAmpEncode _mpenc;

      int _mpsizeb;

      char _mcode[MRA_MAXDIM];
      int _n[MRA_MAXDIM];

      BufferBase* _ptbuffer;

   private:
      MRAmpBase() {}
      virtual void synchronize();

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

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

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

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

   template<class Data_t> friend class MRAmpBuilder;

//   template<class Data_t> friend class MRAmpParser;

};

inline
MRAmpBase::MRAmpBase( BufferBase* ptbuffer ) 
  : _state(0), 
    _ptbuffer(ptbuffer) 
{ 
   set_null(); 
}

inline
MRAmpBase::MRAmpBase( const MRAmpBase& mp, BufferBase* ptbuffer )
  : _state(mp._state), 
    _mpenc(mp._mpenc), _mpsizeb(mp._mpsizeb), _ptbuffer(ptbuffer)
{
   for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
      _mcode[d] = mp._mcode[d];
      _n[d] = mp._n[d];
   }
}

inline
MRAmpBase::MRAmpBase( const MRAmpEncode& mpenc, BufferBase* ptbuffer )
  : _state(goodbit),
    _mpenc(mpenc), _mpsizeb(0), _ptbuffer(ptbuffer)
{
   for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
      _mcode[d] = 0;
      _n[d] = 0;
   }
}

inline
MRAmpBase::~MRAmpBase() 
{
   if ( _ptbuffer != 0 ) { delete _ptbuffer; _ptbuffer = 0; }
}

inline
MRAmpBase& MRAmpBase::copy( const MRAmpBase& mp )
{
   if ( this != &mp ) {
      _state = mp._state;
      _mpenc = mp._mpenc;
      _mpsizeb = mp._mpsizeb;
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _mcode[d] = mp._mcode[d];
         _n[d] = mp._n[d];
      }
      mp._ptbuffer->seekg(0);
      _ptbuffer->erase();
      for( int i = 0; i < mp._mpsizeb; ++i ) {
         _ptbuffer->put( mp._ptbuffer->get() );
      }
   }
   return *this;
}

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

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

inline
MRAmpBase& MRAmpBase::operator () ( const MRAmpBase& mp ) 
{ 
   return copy(mp); 
}

inline
MRAmpBase& MRAmpBase::operator () ( const MRAmpEncode& mpenc )
{
   clear();
   _mpenc = mpenc;
   _mpsizeb = 0;
   for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
      _mcode[d] = 0;
      _n[d] = 0;
   }
   _ptbuffer->erase();
   return *this;
}

inline
bool MRAmpBase::is_equal( const MRAmpBase& mp )
{
   if ( this != &mp ) {
      if ( _state != mp._state ) return false;
      if ( _mpenc != mp._mpenc ) return false;
      if ( _mpsizeb != mp._mpsizeb ) return false;
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         if ( _mcode[d] != mp._mcode[d] ) return false;
         if ( _n[d] != mp._n[d] ) return false;
      }
      int mark = _ptbuffer->tellg();
      int mpmark = mp._ptbuffer->tellg();
      _ptbuffer->seekg(0);
      mp._ptbuffer->seekg(0);
      for( int i = 0; i < _mpsizeb; ++i ) {
         if ( _ptbuffer->get() != mp._ptbuffer->get() ) return false;
      }
      _ptbuffer->seekg(mark);
      mp._ptbuffer->seekg(mpmark);
   }
   return true;
}

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

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

inline
void MRAmpBase::clear() { _state = goodbit; }

inline
void MRAmpBase::setstate( int s ) { _state |= s; }

inline
void MRAmpBase::clrstate( int s ) { _state &= ~s; }

inline
int MRAmpBase::rdstate( int s ) { return (_state & s); }

inline
bool MRAmpBase::good() { return rdstate(goodbit) != 0; }

inline
bool MRAmpBase::fail() { return rdstate(failbit) != 0; }

inline
bool MRAmpBase::baddim() { return rdstate(baddimbit) != 0; }

inline
bool MRAmpBase::hdrfixed() { return rdstate(hdrfixedbit) != 0; }

inline
bool MRAmpBase::mpfixed() { return rdstate(mpfixedbit) != 0; }

inline
MRAmpBase& MRAmpBase::set_null() 
{ 
   _mpsizeb = 0;
   _ptbuffer->erase();
   return *this;
}

inline
bool MRAmpBase::is_null() { return _mpsizeb == 0; }

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

inline
MRAmpBase& MRAmpBase::set_empty() 
{
   clear(); 
   _mpsizeb = hdrsizeb() + _mpenc.bplen_mpsizeb(); 
   _ptbuffer->erase();
   return *this;
}

inline
bool MRAmpBase::is_empty() 
{ 
   return _mpsizeb <= hdrsizeb() + _mpenc.bplen_mpsizeb(); 
}

inline
void MRAmpBase::set_mcode( const char* mcode )
{
   if ( !hdrfixed() && !mpfixed() ) {
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) _mcode[d] = mcode[d];
   } else setstate(failbit);
}

inline
void MRAmpBase::set_mcode( int d, char mcode )
{
   if ( !hdrfixed() && !mpfixed() ) _mcode[d] = mcode;
   else setstate(failbit);
}

inline
void MRAmpBase::set_n( const int* n )
{
   if ( !hdrfixed() && !mpfixed() ) {
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) _n[d] = n[d];
   } else setstate(failbit);
}

inline
void MRAmpBase::set_n( int d, int n ) 
{ 
   if ( !hdrfixed() && !mpfixed() ) _n[d] = n; 
   else setstate(failbit);
}

inline
void MRAmpBase::fix_hdr() { 
   if ( !hdrfixed() && !mpfixed() ) {
      bytepack bp;
      setstate(hdrfixedbit);
      _mpsizeb = hdrsizeb();
      _ptbuffer->seekp(0);
      _ptbuffer->write( bp( _mpsizeb, _mpenc.bplen_mpsizeb() ) );
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _ptbuffer->write( bp( _mcode[d], 1 ) );
      }
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _ptbuffer->write( bp( _n[d], _mpenc.bplen_n(d) ) );
      }
   } else setstate(failbit);
}

inline
void MRAmpBase::refix_hdr() { 
   if ( hdrfixed() && !mpfixed() ) {
      bytepack bp;
      setstate(hdrfixedbit);
//      _mpsizeb = hdrsizeb();
      _ptbuffer->seekp(0);
      _ptbuffer->write( bp( _mpsizeb, _mpenc.bplen_mpsizeb() ) );
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _ptbuffer->write( bp( _mcode[d], 1 ) );
      }
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _ptbuffer->write( bp( _n[d], _mpenc.bplen_n(d) ) );
      }
      _ptbuffer->seekp(_mpsizeb);
   } else setstate(failbit);
}

inline
//void MRAmpBase::append( int a, const Data_t coef )
void MRAmpBase::append( int a, bytepack bpcoef )
{
   if ( hdrfixed() && !mpfixed() ) {
      bytepack bp;
      _ptbuffer->write( bp( a, _mpenc.bplen_a(0) ) );
      _mpsizeb += _mpenc.bplen_a(0);
      _ptbuffer->write( bpcoef );
cout << "append " << float(bpcoef) << endl;
      _mpsizeb += _mpenc.bplen_coef();
   } else setstate(failbit);
}

inline
//void MRAmpBase::append( const int* a, const Data_t coef )
void MRAmpBase::append( const int* a, bytepack bpcoef )
{
   if ( hdrfixed() && !mpfixed() ) {
      bytepack bp;
      for( int d = 0; d < _mpenc.array_dim(); ++d ) {
         _ptbuffer->write( bp( a[d], _mpenc.bplen_a(d) ) );
         _mpsizeb += _mpenc.bplen_a(d);
      }
//      _ptbuffer->write( bp( coef, _mpenc.bplen_coef() ) );
      _ptbuffer->write( bpcoef );
      _mpsizeb += _mpenc.bplen_coef();
   } else setstate(failbit);
}

inline
void MRAmpBase::fix_mp()
{
   if ( hdrfixed() && !mpfixed() ) {
      bytepack bp;
      setstate(mpfixedbit);
      _mpsizeb += _mpenc.bplen_mpsizeb();
      _ptbuffer->write( bp( _mpsizeb, _mpenc.bplen_mpsizeb() ));
      _ptbuffer->seekp(0);
      _ptbuffer->write( bp( _mpsizeb, _mpenc.bplen_mpsizeb() ));
      _ptbuffer->seekp(0,BufferBase::end);
   } else setstate(failbit);
}

inline
void MRAmpBase::unfix_mp()
{
   if ( hdrfixed() && mpfixed() ) {
      bytepack bp;
      clrstate(mpfixedbit);
      _mpsizeb -= _mpenc.bplen_mpsizeb();
//      _ptbuffer->write( bp( _mpsizeb, _mpenc.bplen_mpsizeb() ));
      _ptbuffer->seekp(0);
      _ptbuffer->write( bp( _mpsizeb, _mpenc.bplen_mpsizeb() ));
//      _ptbuffer->seekp(0,BufferBase::end);
      _ptbuffer->seekp(_mpsizeb);
   } else setstate(failbit);
}

inline
void MRAmpBase::write( BufferBase& buffer )
{
   bytepack bp;
   _ptbuffer->erase();
   buffer >> bp( 0, _mpenc.bplen_mpsizeb() ); _mpsizeb = int(bp); 
   _ptbuffer->write(bp);
   if ( _mpsizeb != 0 ) {
      for(int i = _mpenc.bplen_mpsizeb(); i < _mpsizeb; ++i) {
         _ptbuffer->put( buffer.get() );
      }
   }
   else { 
      _ptbuffer->write(bp);
   }
   synchronize();
}

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

inline
void MRAmpBase::read( BufferBase& buffer )
{
   if ( !is_null() ) {
      _ptbuffer->seekg(0);
      for( int i = 0; i < _mpsizeb; ++i ) {
         buffer.put( _ptbuffer->get() );
      }
   }
   else { 
       bytepack bp;
       buffer << bp( 0, _mpenc.bplen_mpsizeb() );
       buffer << bp( 0, _mpenc.bplen_mpsizeb() );
   }
}

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

inline
void MRAmpBase::write( istream& is )
{
   bytepack bp;
   _ptbuffer->erase();
   is >> bp( 0, _mpenc.bplen_mpsizeb() ); _mpsizeb = int(bp);
   _ptbuffer->write(bp);
   if ( _mpsizeb != 0 ) {
      for(int i = _mpenc.bplen_mpsizeb(); i < _mpsizeb; ++i) {
         _ptbuffer->put( is.get() );
      }
   }
   else { 
      _ptbuffer->write(bp);
   }
   synchronize();
}

inline
void MRAmpBase::read( ostream& os )
{
   if ( !is_null() ) {
      _ptbuffer->seekg(0);
      for( int i = 0; i < _mpsizeb; ++i ) {
         os.put( _ptbuffer->get() );
      }
   }
   else { 
       bytepack bp;
       os << bp( 0, _mpenc.bplen_mpsizeb() );
       os << bp( 0, _mpenc.bplen_mpsizeb() );
   }
}

inline
int MRAmpBase::hdrsizeb()
{
   int tmp =  _mpenc.bplen_mpsizeb() + _mpenc.grid_dim();
   for( int d = 0; d < _mpenc.grid_dim(); ++d ) { tmp += _mpenc.bplen_n(d); }
   return tmp;
}

inline
int MRAmpBase::acoefsizeb()
{
   int tmp =  _mpenc.bplen_coef();
   for( int d = 0; d < _mpenc.grid_dim(); ++d ) { tmp += _mpenc.bplen_a(d); }
   return tmp;
}

inline
MRAmpEncode& MRAmpBase::mpenc() { return _mpenc; }

inline
int MRAmpBase::mpsizeb() { return _mpsizeb; }

inline
int MRAmpBase::mcode( int d  ) { return _mcode[d]; }

inline
int MRAmpBase::n( int d  ) { return _n[d]; }

inline
int MRAmpBase::nullsizeb() { return 2 * _mpenc.bplen_mpsizeb(); }

inline
int MRAmpBase::mcode_to_m( int d ) 
{ 
   return ::mcode_to_m( _mcode[d] ); 
}

inline
int MRAmpBase::mcode_to_sw( int d ) 
{ 
   return ::mcode_to_sw( _mcode[d] ); 
}

inline
int MRAmpBase::mcode_to_rs( int d ) 
{ 
   return ::mcode_to_rs( _mcode[d] ); 
}

inline
int MRAmpBase::mcode_to_order( int d ) 
{ 
   return ::mcode_to_order( _mcode[d] ); 
}

inline
void MRAmpBase::report( ostream& os ) 
{
   os << "MRAmpBase::report mpenc:\n";
   _mpenc.report(os);
   os << "MRAmpBase::report mpsizeb =" << _mpsizeb << '\n';
   for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
      os << "MRAmpBase::report int(mcode[" << d << "])=" 
         << int(_mcode[d]) << '\n';
   }
   for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
      os << "MRAmpBase::report n[" << d << "]=" 
         << _n[d] << '\n';
   }
}

inline
void MRAmpBase::synchronize()
{
   bytepack bp;
   _ptbuffer->seekg(0);
   _ptbuffer->read( bp( 0, _mpenc.bplen_mpsizeb() ) ); _mpsizeb = int(bp);
   if ( _mpsizeb != 0 ) {
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _ptbuffer->read( bp(0,1) ); _mcode[d] = char(bp);
      }
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _ptbuffer->read( bp( 0, _mpenc.bplen_n(d) ) ); _n[d] = int(bp);
      }
   }
   else { 
      for( int d = 0; d < _mpenc.grid_dim(); ++d ) {
         _mcode[d] = 0;
         _n[d] = 0;
      }
   }
}

inline
MRAmpBase::iterator MRAmpBase::begin()
{
   iterator iter(this);
//   if ( hdrfixed() && sbfixed() ) {
      iter._pos = hdrsizeb();
//   } else {
//      iter.set_null();
//   }
   return iter;
}

inline
MRAmpBase::iterator MRAmpBase::end()
{
   iterator iter(this);
//   if ( hdrfixed() && sbfixed() ) {
//      iter._pos = _sbsizeb - 4 - _mpenc.bplen_mpsizeb() * 2;
//      iter._pos = mpsizeb();
      iter._pos = mpsizeb() - _mpenc.bplen_mpsizeb();
//   }  else {
//      iter.set_null();
//   }
   return iter;
}

// ##### MRAmpBase::iterator #####

inline
MRAmpBase::iterator::iterator( MRAmpBase* ptmp ) 
  : _pos(0), _ptmp(ptmp)
{}

inline
MRAmpBase::iterator::~iterator() { _ptmp = 0; }

inline
MRAmpBase::iterator& 
  MRAmpBase::iterator::operator ++ ()
{ 
   if ( !is_null() ) {
      bytepack bp;
      int tmppos = _ptmp->_ptbuffer->tellg();
      _ptmp->_ptbuffer->seekg(_pos);

//      mp.write( *(_ptsb->_ptbuffer) );
      for( int d = 0; d < _ptmp->_mpenc.array_dim(); ++d ) {
         _ptmp->_ptbuffer->read( bp( 0, _ptmp->_mpenc.bplen_a(d) ) ); 
           // _a[d] = int(bp);
      }
      _ptmp->_ptbuffer->read( bp( 0, _ptmp->_mpenc.bplen_coef() ) ); 
        //_coef = Data_t(bp);

      _pos = _ptmp->_ptbuffer->tellg();
      _ptmp->_ptbuffer->seekg(tmppos);
   }
   return *this; 
}

inline
MRAacoef MRAmpBase::iterator::operator * () 
{ 
      bytepack bp;
      MRAacoef acoef( _ptmp->_mpenc.array_dim() );
   if ( !is_null() ) {
      int tmppos = _ptmp->_ptbuffer->tellg();
      _ptmp->_ptbuffer->seekg(_pos);

//      mp.write( *(_ptsb->_ptbuffer) );
      for( int d = 0; d < _ptmp->_mpenc.array_dim(); ++d ) {
         _ptmp->_ptbuffer->read( bp( 0, _ptmp->_mpenc.bplen_a(d) ) ); 
         acoef.a[d] = int(bp);
      }
      _ptmp->_ptbuffer->read( bp( 0, _ptmp->_mpenc.bplen_coef() ) ); 
      acoef.bpcoef = bp;

      _ptmp->_ptbuffer->seekg(tmppos);
   }
   return acoef; 
}

inline
void MRAmpBase::iterator::set_null() { _pos = 0; }

inline
bool MRAmpBase::iterator::is_null() { return ( _pos == 0 ); }

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

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

inline
bool MRAmpBase::iterator::is_equal( const iterator& iter )
{
  return ( _pos == iter._pos );
}

inline
bool MRAmpBase::iterator::operator == ( const iterator& iter )
{
  return is_equal(iter);
}

inline
bool MRAmpBase::iterator::operator != ( const iterator& iter) 
{ 
  return !is_equal(iter);
} 

inline
bool MRAmpBase::iterator::operator > ( const iterator& iter )
{
  return ( _pos > iter._pos );
}

inline
bool MRAmpBase::iterator::operator < ( const iterator& iter )
{
  return ( _pos < iter._pos );
}

inline
bool MRAmpBase::iterator::operator >= ( const iterator& iter )
{
   return ( ( *this > iter ) ||  ( *this == iter ) );
}

inline
bool MRAmpBase::iterator::operator <= ( const iterator& iter)
{
   return ( ( *this < iter ) ||  ( *this == iter ) );
}

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

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

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

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

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

#endif

---