MRAsbBase.h

Go to the documentation of this file.

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

#ifndef MRASBBASE_H
#define MRASBBASE_H

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

#include "DataTypeCode.h"
#include "BufferBase.h"
#include "MRAmp.h"
#include "MRAmpEncode.h"
#include "MRAsbn.h"
#include "MRAmspec.h"
#include "MRAcspec.h"
#include "ilog2.h"

#ifndef MRA_MAXDIM
#define MRA_MAXDIM 4
#endif

#ifndef MRASBBASE_PROCESS_MAXSIZEB
#define MRASBBASE_PROCESS_MAXSIZEB 256
#endif

inline int castc_float( bytepack bp ) { return ilog2( float(bp) ); }
inline int castc_double( bytepack bp ) { return ilog2( double(bp) ); }

class MRAsbBase
{
   public:

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

      static const int     goodbit = 0x01;
      static const int     failbit = 0x02;
      static const int   baddimbit = 0x04;
      static const int     fragbit = 0x08;
      static const int hdrfixedbit = 0x10;
      static const int  sbfixedbit = 0x20;

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

      virtual ~MRAsbBase();

      MRAsbBase& copy( const MRAsbBase& );
      MRAsbBase& operator = ( const MRAsbBase& );
      MRAsbBase& copy( MRAsbBase&, MRAmrange );
//      MRAsbBase& test_copy_crange( MRAsbBase&, MRAcrange );
      MRAsbBase& copy( MRAsbBase&, MRAcrange );
      MRAsbBase& copy( MRAsbBase&, MRAmrange, MRAcrange );

      MRAsbBase& operator () ( BufferBase* );
      MRAsbBase& operator () ( const MRAsbBase&, BufferBase* );
      MRAsbBase& operator () ( const MRAmpEncode&, BufferBase* );

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

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

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

      MRAsbBase& set_empty();
      bool is_empty();

      void fix_hdr();
      void fix_sb();
      void unfix_sb();

      void refix_hdr(); // THIS IS A HACK.  THIS CLASS MUST BE
                        // REDESIGNED FOR BETTER MANIPULATION OF hdr

      void set_sbn();
      void set_sbn( const MRAsbn& );
      void set_sbn( int sbn );

      void set_mspec();
      void set_mspec( const MRAmspec& );
      void set_mspec( 
        const MRAmrange& mthis, 
        const MRAmrange& mexist,
        const MRAmrange& mtheory
      );
      void set_mspec( const MRAmrange& mthis );

      void set_cspec();
      void set_cspec( const MRAcspec& );
      void set_cspec( 
        const MRAcrange& cthis, 
        const MRAcrange& cexist,
        const MRAcrange& ctheory
      );
      void set_cspec( const MRAcrange& cthis );

      void set_datatypecode( int datatypecode );

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

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

      void recover( BufferBase& );
      void recover( istream& );

      MRAmpEncode& mpenc();

      int sbsizeb();

      MRAsbn& sbn();
      MRAmspec& mspec();
      MRAcspec& cspec();

      int datatypecode();

      int process_sizeb();
      int process_method();
      char* process();
      char process( int i );

      int hdrsizeb();

      bool mmatch( MRAmrange, MRAmpBase& );

      MRAsbBase& append( MRAmpBase& );
      MRAsbBase& append_null();
      MRAsbBase& append( MRAsbBase& );
      MRAsbBase& append( MRAsbBase&, MRAmrange );
      MRAsbBase& append( MRAsbBase&, MRAcrange );
      MRAsbBase& append( MRAsbBase&, MRAmrange, MRAcrange );

      class iterator
      {
         public:
            iterator( MRAsbBase* );
            ~iterator();
            iterator& operator ++ ();
            MRAmp 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;
            MRAsbBase* _ptsb;
         private:
            iterator() {}
         friend class MRAsbBase;
      };

      iterator begin();
      iterator end();

   protected:
      int _state;

      MRAmpEncode _mpenc;

      int _sbsizeb;

      MRAsbn _sbn;
      MRAmspec _mspec;
      MRAcspec _cspec;

      int _datatypecode;
      int _process_sizeb;
      int _process_method;
      char _process[MRASBBASE_PROCESS_MAXSIZEB];

      BufferBase* _ptbuffer;

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

   friend class iterator; 

   friend class MRAsbObject;

   friend BufferBase& operator << ( BufferBase&, MRAsbBase& );
   friend BufferBase& operator >> ( BufferBase&, MRAsbBase& );

   friend ostream& operator << ( ostream&, MRAsbBase& );
   friend istream& operator >> ( istream&, MRAsbBase& );

};

inline
MRAsbBase::MRAsbBase( BufferBase* ptbuffer ) 
  : _ptbuffer(ptbuffer)
{
   set_null();
   _ptbuffer->erase();
}

inline
MRAsbBase::MRAsbBase( const MRAsbBase& sb, BufferBase* ptbuffer )
  : _state(sb._state), _mpenc(sb._mpenc),
    _sbsizeb(sb._sbsizeb),
    _sbn(sb._sbn), _mspec(sb._mspec), _cspec(sb._cspec),
    _datatypecode(sb._datatypecode),
    _process_sizeb(sb._process_sizeb), _process_method(sb._process_method),
    _ptbuffer(ptbuffer)
{
   
   for( int i = 0; i < process_sizeb(); ++i ) _process[i] = sb._process[i];
   sb._ptbuffer->seekg(0);
   _ptbuffer->seekp(0);
   for( int i = 0; i < sb._ptbuffer->size(); ++i ) {
      _ptbuffer->put( sb._ptbuffer->get() );
   }
}

inline
MRAsbBase::MRAsbBase( const MRAmpEncode& mpenc, BufferBase* ptbuffer )
  : _state(goodbit), _mpenc(mpenc), 
    _sbsizeb(0), 
    _sbn( _mpenc.grid_dim() ), _mspec( _mpenc.grid_dim() ), 
    _datatypecode(0),
    _process_sizeb(3), _process_method(0),
    _ptbuffer(ptbuffer)
{}

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

inline
MRAsbBase& MRAsbBase::operator () ( BufferBase* ptbuffer ) 
{ 
   if ( _ptbuffer != 0 ) delete _ptbuffer; 
   _ptbuffer = ptbuffer;
   set_null(); 
   return *this;
}

inline
MRAsbBase& MRAsbBase::operator () ( const MRAsbBase& sb, BufferBase* ptbuffer )
{
   _state = sb._state;
   _mpenc = sb._mpenc;
   _sbsizeb = sb._sbsizeb;
   _sbn = sb._sbn;
   _mspec = sb._mspec;
   _cspec = sb._cspec;
   _datatypecode = sb._datatypecode;
   _process_sizeb = sb._process_sizeb;
   _process_method = sb._process_method;
   if ( _ptbuffer != 0 ) delete _ptbuffer; 
   _ptbuffer = ptbuffer; 
   for( int i = 0; i < process_sizeb(); ++i ) _process[i] = sb._process[i];
   sb._ptbuffer->seekg(0);
   _ptbuffer->seekp(0);
   char c;
   for( int i = 0; i < sb._ptbuffer->size(); ++i ) {
      c = sb._ptbuffer->get();
      _ptbuffer->put( c );
   }
   return *this;
}

inline
MRAsbBase& MRAsbBase::operator () ( 
  const MRAmpEncode& mpenc, BufferBase* ptbuffer  
)
{
   _state = goodbit;
   _mpenc = mpenc;
   _sbsizeb = 0;
   _sbn(_mpenc.grid_dim());
   _mspec(_mpenc.grid_dim());
   _datatypecode = 0;
   _process_sizeb = 3;
   _process_method = 0;
   if ( _ptbuffer != 0 ) delete _ptbuffer; 
   _ptbuffer = ptbuffer;
   return *this;
}

inline
MRAsbBase& MRAsbBase::copy( const MRAsbBase& sb ) 
{
   if ( this != &sb ) {
      _state = sb._state;
      _mpenc = sb._mpenc;
      _sbsizeb = sb._sbsizeb;
      _sbn( _mpenc.grid_dim() ) = sb._sbn;
      _mspec( _mpenc.grid_dim() ) = sb._mspec;
      _cspec = sb._cspec;
      _datatypecode = sb._datatypecode;
      _process_sizeb = sb._process_sizeb;
      _process_method = sb._process_method;
      for( int i = 0; i < process_sizeb(); ++i ) _process[i]=sb._process[i];
      sb._ptbuffer->seekg(0);
      _ptbuffer->seekp(0);
      char c;
      for( int i = 0; i < sb._ptbuffer->size(); ++i ) {
         c = sb._ptbuffer->get();
         _ptbuffer->put( c );
      }
   }
   return *this;
}

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

inline
MRAsbBase& MRAsbBase::copy( MRAsbBase& sb, MRAmrange mrange ) 
{
   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   clear();
   _mpenc = sb._mpenc;
   _sbsizeb = 0;
   set_sbn( sb.sbn() );
   set_mspec( sb.mspec() );
   set_mspec( mrange * sb.mspec().mthis );
   set_cspec( sb.cspec() );
   set_datatypecode( sb.datatypecode() );
   _process_sizeb = sb.process_sizeb();
   _process_method = sb.process_method();
   for( int i = 0; i < _process_sizeb - 3; ++i ) {
      _process[i] = sb.process(i);
   }
 
   fix_hdr();

   MRAmlevel mlevel( _mpenc.grid_dim() );
   MRAmp mp;
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
      if ( mlevel <= mrange ) append(mp);
   }

   fix_sb();

   return *this;
}

/*
inline
MRAsbBase& MRAsbBase::test_copy_crange( MRAsbBase& sb, MRAcrange crange ) 
{
//this should becom part of class
   int (*castc)( bytepack );
   if ( _datatypecode == DataTypeCode_type<float>::code() ) {
      castc = castc_float;
   } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
      castc = castc_double;
   } else {
      castc = 0;
   }

   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   clear();
   _mpenc = sb._mpenc;
   _sbsizeb = 0;
   set_sbn( sb.sbn() );
   set_mspec( sb.mspec() );
   set_cspec( sb.cspec() );
   set_cspec( crange * sb.cspec().cthis );
   set_datatypecode( sb.datatypecode() );
   _process_sizeb = sb.process_sizeb();
   _process_method = sb.process_method();
   for(int i = 0; i < _process_sizeb - 3; ++i ) { _process[i] = sb.process(i);} 
   fix_hdr();

   MRAmlevel mlevel( _mpenc.grid_dim() );
   MRAmp mp;
   MRAmp mp2(_mpenc);
//   MRAmpBuilder<float> mpbuilder2;
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      mp2 = mp;
//      mpbuilder2(mp2);
      mp2.set_empty();
      mp2.fix_hdr();
      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
cout << "parse mp of sizeb " << mp.mpsizeb() << endl;

         MRAacoef acoef;
         MRAclevel clevel;
         for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
            acoef = *itmp;
            cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
                 << castc(acoef.bpcoef) << endl;
            clevel = castc(acoef.bpcoef);
            if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
//            mp2.append( acoef.a, acoef.bpcoef );
//clevel.report();
//crange.report();
         }
         mp2.fix_mp();

//      if ( mlevel <= mrange ) append(mp);
      append(mp2);

   }

   fix_sb();

   return *this;
}
*/

inline
MRAsbBase& MRAsbBase::copy( MRAsbBase& sb, MRAcrange crange ) 
{
//this should becom part of class
   int (*castc)( bytepack );
   if ( _datatypecode == DataTypeCode_type<float>::code() ) {
      castc = castc_float;
   } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
      castc = castc_double;
   } else {
      castc = 0;
   }

   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   clear();
   _mpenc = sb._mpenc;
   _sbsizeb = 0;
   set_sbn( sb.sbn() );
   set_mspec( sb.mspec() );
   set_cspec( sb.cspec() );
   set_cspec( crange * sb.cspec().cthis );
   set_datatypecode( sb.datatypecode() );
   _process_sizeb = sb.process_sizeb();
   _process_method = sb.process_method();
   for(int i = 0; i < _process_sizeb - 3; ++i ) { _process[i] = sb.process(i);} 
   fix_hdr();

   MRAmlevel mlevel( _mpenc.grid_dim() );
   MRAmp mp;
   MRAmp mp2(_mpenc);
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      mp2 = mp;
      mp2.set_empty();
      mp2.fix_hdr();
      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);

      MRAacoef acoef;
      MRAclevel clevel;
      for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
         acoef = *itmp;
//         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
//              << castc(acoef.bpcoef) << endl;
         clevel = castc(acoef.bpcoef);
         if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
      }

      mp2.fix_mp();

      append(mp2);
   }

   fix_sb();

   return *this;
}

inline
MRAsbBase& MRAsbBase::copy( MRAsbBase& sb, MRAmrange mrange, MRAcrange crange ) 
{
//this should becom part of class
   int (*castc)( bytepack );
   if ( _datatypecode == DataTypeCode_type<float>::code() ) {
      castc = castc_float;
cout << "cast as float\n";
   } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
      castc = castc_double;
cout << "cast as double\n";
   } else {
      castc = 0;
   }

   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   clear();
   _mpenc = sb._mpenc;
   _sbsizeb = 0;
   set_sbn( sb.sbn() );
   set_mspec( sb.mspec() );
   set_cspec( sb.cspec() );
   set_cspec( crange * sb.cspec().cthis );
   set_datatypecode( sb.datatypecode() );
   _process_sizeb = sb.process_sizeb();
   _process_method = sb.process_method();
   for(int i = 0; i < _process_sizeb - 3; ++i ) { _process[i] = sb.process(i);} 
   fix_hdr();

   MRAmlevel mlevel( _mpenc.grid_dim() );
   MRAmp mp;
   MRAmp mp2(_mpenc);
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      mp2 = mp;
      mp2.set_empty();
      mp2.fix_hdr();
      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
      if ( mlevel <= mrange ) {
         MRAacoef acoef;
         MRAclevel clevel;
         for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
         acoef = *itmp;
//         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
//              << castc(acoef.bpcoef) << endl;
            clevel = castc(acoef.bpcoef);
            if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
         }

         mp2.fix_mp();

         append(mp2);
      }
   }

   fix_sb();

   return *this;
}

inline
bool MRAsbBase::is_equal( const MRAsbBase& sb ) 
{
   if ( this != &sb ) {
      if ( _state != sb._state ) return false;
      if ( _mpenc != sb._mpenc ) return false;
      if ( _sbsizeb != sb._sbsizeb ) return false;
      if ( _sbn != sb._sbn ) return false;
      if ( _mspec != sb._mspec ) return false;
      if ( _cspec != sb._cspec ) return false;
      if ( _datatypecode != sb._datatypecode ) return false;
      if ( _process_sizeb != sb._process_sizeb ) return false;
      if ( _process_method != sb._process_method ) return false;
      for( int i = 0; i < _process_sizeb - 3; ++i ) {
         if ( _process[i] != sb._process[i] ) return false;
      }
      int mark = _ptbuffer->tellg();
      int sbmark = sb._ptbuffer->tellg();
      _ptbuffer->seekg(0);
      sb._ptbuffer->seekg(0);
      for( int i = 0; i < process_sizeb() - 3; ++i ) {
         if ( _ptbuffer->get() != sb._ptbuffer->get() ) return false;
      }
      _ptbuffer->seekg(mark);
      sb._ptbuffer->seekg(sbmark);
   }
   return true;
}

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

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

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

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

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

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

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

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

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

inline
bool MRAsbBase::frag() { return rdstate(fragbit) != 0; }

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

inline
bool MRAsbBase::sbfixed() { return rdstate(sbfixedbit) != 0; }

inline
MRAsbBase& MRAsbBase::set_null() 
{ 
   _state = 0;
   _mpenc.set_null();
   _sbsizeb = 0;
   _sbn(0);
   _mspec(0);
   _datatypecode = 0;
   _process_sizeb = 3;
   _process_method = 0;
   _ptbuffer->erase();
   return *this;
}

inline
bool MRAsbBase::is_null() { return (_sbsizeb == 0); }

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

inline
MRAsbBase& MRAsbBase::set_empty() 
{ 
   clear();
   _ptbuffer->erase();
   fix_hdr();
   fix_sb();
   return *this;
}

inline
void MRAsbBase::fix_hdr() { 
   if ( !hdrfixed() ) {
      bytepack bp;
      setstate(hdrfixedbit);
      _sbsizeb = hdrsizeb();
      _ptbuffer->seekp(0);
      _ptbuffer->write( bp( 0, 4 ) );

      *_ptbuffer << _mpenc;
      *_ptbuffer << _sbn;
      *_ptbuffer << _mspec;
      *_ptbuffer << _cspec;

      _ptbuffer->write( bp( _datatypecode, 1 ) );
      _ptbuffer->write( bp( _process_sizeb, 1 ) );
      _ptbuffer->write( bp( _process_method, 1 ) );
      for( int i = 0; i < _process_sizeb - 3; ++i ) {
         _ptbuffer->put( _process[i] );
      }
      _ptbuffer->write( bp( process_sizeb(), 1 ) );
   }
   else { setstate(failbit); }
}

inline
void MRAsbBase::fix_sb()
{
   if ( hdrfixed() && !sbfixed() ) {
      bytepack bp;
      append_null();
      setstate(sbfixedbit);
      _sbsizeb += 4;
      _ptbuffer->write( bp( _sbsizeb, 4 ) );
      _ptbuffer->seekp(0);
      _ptbuffer->write( bp( _sbsizeb, 4 ) );
      _ptbuffer->seekp(0,BufferBase::end);
   }
   else { setstate(failbit); }
}

inline
void MRAsbBase::unfix_sb()
{
   if ( hdrfixed() && sbfixed() ) {
      bytepack bp;
      _ptbuffer->seekp(0);
      _ptbuffer->write( bp( 0, 4 ) );
      MRAmp mp( _mpenc );
      _sbsizeb -= ( mp.nullsizeb() + 4 );
      _ptbuffer->seekp( _sbsizeb );
      clrstate(sbfixedbit);
   }
   else { setstate(failbit); }
}

inline
void MRAsbBase::refix_hdr() { 
   if ( hdrfixed() ) {
      bytepack bp;
//      setstate(hdrfixedbit);
//      _sbsizeb = hdrsizeb();
      int save_putpos = _ptbuffer->tellp();
      _ptbuffer->seekp(0);

      if ( sbfixed() ) _ptbuffer->write( bp( _sbsizeb, 4 ) );
      else _ptbuffer->write( bp( 0, 4 ) );

      *_ptbuffer << _mpenc;
      *_ptbuffer << _sbn;
      *_ptbuffer << _mspec;
      *_ptbuffer << _cspec;

      _ptbuffer->write( bp( _datatypecode, 1 ) );

// *** REWRITING process IS VERY DANGEROUS AND SHOULD NOT
// *** BE DONE.  MORE REASON FOR CLASS REDESIGN
//      _ptbuffer->write( bp( _process_sizeb, 1 ) );
//      _ptbuffer->write( bp( _process_method, 1 ) );
//      for( int i = 0; i < _process_sizeb - 3; ++i ) {
//         _ptbuffer->put( _process[i] );
//      }
//      _ptbuffer->write( bp( process_sizeb(), 1 ) );

      _ptbuffer->seekp(save_putpos);
 
   }
   else { setstate(failbit); }
}

inline
void MRAsbBase::set_sbn()
{
   _sbn = 0;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_sbn( const MRAsbn& sbn ) 
{ 
   _sbn = sbn;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_sbn( int sbn )
{
   _sbn = sbn;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_mspec()
{
   _mspec.mthis.mmin = MRAmlevel::mmin_limit;
   _mspec.mthis.mmax = MRAmlevel::mmax_limit;

   _mspec.mexist.mmin = MRAmlevel::mmin_limit;
   _mspec.mexist.mmax = MRAmlevel::mmax_limit;

   _mspec.mtheory.mmin = MRAmlevel::mmin_limit;
   _mspec.mtheory.mmax = MRAmlevel::mmax_limit;
   
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_mspec( const MRAmspec& mspec ) 
{ 
   _mspec = mspec; 
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_mspec( 
  const MRAmrange& mthis, const MRAmrange& mexist, const MRAmrange& mtheory
)
{
   _mspec.mthis = mthis;
   _mspec.mexist = mexist;
   _mspec.mtheory = mtheory;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_mspec( const MRAmrange& mthis )
{
   _mspec.mthis = mthis;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_cspec()
{
   _cspec.cthis.cmin = MRAclevel::cmin_limit;
   _cspec.cthis.cmax = MRAclevel::cmax_limit;

   _cspec.cexist.cmin = MRAclevel::cmin_limit;
   _cspec.cexist.cmax = MRAclevel::cmax_limit;

   _cspec.ctheory.cmin = MRAclevel::cmin_limit;
   _cspec.ctheory.cmax = MRAclevel::cmax_limit;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_cspec( const MRAcspec& cspec ) 
{ 
   _cspec = cspec; 
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_cspec( 
  const MRAcrange& cthis, const MRAcrange& cexist, const MRAcrange& ctheory
)
{
   _cspec.cthis = cthis;
   _cspec.cexist = cexist;
   _cspec.ctheory = ctheory;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_cspec( const MRAcrange& cthis )
{
   _cspec.cthis = cthis;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::set_datatypecode( int datatypecode ) 
{
   _datatypecode = datatypecode;
   if ( hdrfixed() ) refix_hdr();
}

inline
void MRAsbBase::write( BufferBase& buffer )
{
   bytepack bp;
   _ptbuffer->erase();
   buffer >> bp(0,4); _sbsizeb = int(bp);
   _ptbuffer->write(bp);
   if ( _sbsizeb == 0 ) { 
      _ptbuffer->write(bp); 
   }
   else if ( _sbsizeb != -1 ) { 
      for( int i = 4; i < _sbsizeb; ++i ) _ptbuffer->put( buffer.get() );
   } else { 
      recover(buffer); 
   }
   clear();
   setstate(hdrfixedbit);
   setstate(sbfixedbit);
   synchronize();
}

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

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

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

inline
void MRAsbBase::write( istream& is )
{
   bytepack bp;
   _ptbuffer->erase();
   is >> bp(0,4); _sbsizeb = int(bp);
   _ptbuffer->write(bp);
   if ( _sbsizeb == 0 ) { _ptbuffer->write(bp); }
   else {
      if ( _sbsizeb != -1 ) {
         for( int i = 4; i < _sbsizeb; ++i ) _ptbuffer->put( is.get() );
      }
      else {
         recover(is);   
      }
   }
   clear();
   setstate(hdrfixedbit);
   setstate(sbfixedbit);
   synchronize();
}

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

inline
void MRAsbBase::recover( BufferBase& buffer ) { 
      bytepack bp;
      buffer >> _mpenc;
      *_ptbuffer << _mpenc;
//      _mpenc.report();

      _sbn( _mpenc.grid_dim() );
      buffer >> _sbn; *_ptbuffer << _sbn;

      _mspec( _mpenc.grid_dim() );
      buffer >> _mspec; *_ptbuffer << _mspec;

      buffer >> _cspec; *_ptbuffer << _cspec;

      buffer >>  bp( 0, 1 ); _datatypecode = int(bp);
      _ptbuffer->write( bp( _datatypecode, 1 ) );
      buffer >>  bp( 0, 1 ); _process_sizeb = int(bp);
      _ptbuffer->write( bp( _process_sizeb, 1 ) );
      buffer >>  bp( 0, 1 ); _process_method = int(bp);
      _ptbuffer->write( bp( _process_method, 1 ) );
      for( int i = 0; i < _process_sizeb - 3; ++i ) {
         buffer.get( _process[i] );
         _ptbuffer->put( _process[i] );
      }
      buffer >>  bp( 0, 1 ); int tmp = int(bp);
      _ptbuffer->write( bp( tmp, 1 ) );

      _sbsizeb = hdrsizeb();
      int mpsizeb;
      do { 
         buffer >> bp( 0, _mpenc.bplen_mpsizeb() ); mpsizeb = int(bp);
         _ptbuffer->write( bp( mpsizeb, _mpenc.bplen_mpsizeb() ) );
         if ( mpsizeb != 0 ) {
            for( int i = 0; i < mpsizeb - _mpenc.bplen_mpsizeb(); ++i ) {
               _ptbuffer->put( buffer.get() );
            }
            _sbsizeb += mpsizeb;
         }
         else {
            buffer >> bp( 0, _mpenc.bplen_mpsizeb() );
            _ptbuffer->write( bp( 0, _mpenc.bplen_mpsizeb() ) );
            _sbsizeb += 2 * _mpenc.bplen_mpsizeb();
         }
      } while ( mpsizeb != 0 );
      buffer >> bp( 0, 4 );
      _sbsizeb += 4;
      _ptbuffer->write( bp( _sbsizeb, 4 ) );
      synchronize();
}
inline
void MRAsbBase::recover( istream& is ) { 
      bytepack bp;
      is >> _mpenc;
      *_ptbuffer << _mpenc;
//      _mpenc.report();

      _sbn( _mpenc.grid_dim() );
      is >> _sbn; *_ptbuffer << _sbn;

      _mspec( _mpenc.grid_dim() );
      is >> _mspec; *_ptbuffer << _mspec;

      is >> _cspec; *_ptbuffer << _cspec;

      is >>  bp( 0, 1 ); _datatypecode = int(bp);
      _ptbuffer->write( bp( _datatypecode, 1 ) );
      is >>  bp( 0, 1 ); _process_sizeb = int(bp);
      _ptbuffer->write( bp( _process_sizeb, 1 ) );
      is >>  bp( 0, 1 ); _process_method = int(bp);
      _ptbuffer->write( bp( _process_method, 1 ) );
      for( int i = 0; i < _process_sizeb - 3; ++i ) {
         is.get( _process[i] );
         _ptbuffer->put( _process[i] );
      }
      is >>  bp( 0, 1 ); int tmp = int(bp);
      _ptbuffer->write( bp( tmp, 1 ) );

      _sbsizeb = hdrsizeb();
      int mpsizeb;
      do { 
         is >> bp( 0, _mpenc.bplen_mpsizeb() ); mpsizeb = int(bp);
         _ptbuffer->write( bp( mpsizeb, _mpenc.bplen_mpsizeb() ) );
         if ( mpsizeb != 0 ) {
            for( int i = 0; i < mpsizeb - _mpenc.bplen_mpsizeb(); ++i ) {
               _ptbuffer->put( is.get() );
            }
            _sbsizeb += mpsizeb;
         }
         else {
            is >> bp( 0, _mpenc.bplen_mpsizeb() );
            _ptbuffer->write( bp( 0, _mpenc.bplen_mpsizeb() ) );
            _sbsizeb += 2 * _mpenc.bplen_mpsizeb();
         }
      } while ( mpsizeb != 0 );
      is >> bp( 0, 4 );
      _sbsizeb += 4;
      _ptbuffer->write( bp( _sbsizeb, 4 ) );
      synchronize();
}


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

inline
int MRAsbBase::sbsizeb() { return _sbsizeb; }

inline
MRAsbn& MRAsbBase::sbn() { return _sbn; }

inline
MRAmspec& MRAsbBase::mspec() { return _mspec; }

inline
MRAcspec& MRAsbBase::cspec() { return _cspec; }

inline
int MRAsbBase::datatypecode() { return _datatypecode; }

inline
int MRAsbBase::process_sizeb() { return _process_sizeb; }

inline
int MRAsbBase::process_method() { return _process_method; }

inline
char* MRAsbBase::process() { return _process; }

inline
char MRAsbBase::process( int i ) { return _process[i]; }

inline
int MRAsbBase::hdrsizeb() 
{
   return 5 + _mpenc.sizeb() + _sbn.sizeb()
            + _mspec.sizeb() + _cspec.sizeb() 
            + _process_sizeb;
}

inline
bool MRAsbBase::mmatch( MRAmrange mrange, MRAmpBase& mp )
{
   MRAmlevel tmpmlevel( _mpenc.grid_dim() );
   for(int d = 0; d < _mpenc.grid_dim(); ++d ) tmpmlevel[d] = mp.mcode_to_m(d);
   return ( tmpmlevel <= mrange  );
}

inline
MRAsbBase& MRAsbBase::append( MRAmpBase& mp )
{
   if ( hdrfixed() && !sbfixed() ) {
      if ( _mpenc == mp.mpenc() ) {
         mp.read( *_ptbuffer );
         _sbsizeb += mp.mpsizeb();
      }
      else { setstate(failbit); }
   }
   else { setstate(failbit); }
   return *this;
}

inline
MRAsbBase& MRAsbBase::append_null()
{
   if ( hdrfixed() && !sbfixed() ) {
      MRAmp mp( mpenc() );
      mp.set_null();
      mp.read( *_ptbuffer ); 
      _sbsizeb += mp.nullsizeb();
   }
   else { setstate(failbit); }
   return *this;
}

inline
MRAsbBase& MRAsbBase::append( MRAsbBase& sb ) 
{
   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _mpenc != sb._mpenc ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _sbn != sb._sbn ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
//   if ( !connected( _mspec.mthis, sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
//   if ( !disjoint( _mspec.mthis, sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
   if ( _datatypecode != sb._datatypecode ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_sizeb != sb._process_sizeb) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_method != sb._process_method) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   for( int i = 0; i < _process_sizeb - 3; ++i ) {
      if ( _process[i] != sb._process[i] ) {
         clrstate(goodbit), setstate(failbit);
         return *this;
      }
   }
 
   unfix_sb();

   MRAmp mp;
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      append(mp);
   }

   fix_sb();

   set_mspec( _mspec.mthis + sb._mspec.mthis );

   return *this;
}

inline
MRAsbBase& MRAsbBase::append( MRAsbBase& sb, MRAmrange mrange ) 
{
   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _mpenc != sb._mpenc ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _sbn != sb._sbn ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
//   if ( !connected( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
//   if ( !disjoint( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
   if ( _datatypecode != sb._datatypecode ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_sizeb != sb._process_sizeb) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_method != sb._process_method) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   for( int i = 0; i < _process_sizeb - 3; ++i ) {
      if ( _process[i] != sb._process[i] ) {
         clrstate(goodbit), setstate(failbit);
         return *this;
      }
   }
  
   unfix_sb();

   MRAmlevel mlevel( _mpenc.grid_dim() );
   MRAmp mp;
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
      if ( mlevel <= mrange ) append(mp);
   }

   fix_sb();

   set_mspec( _mspec.mthis + mrange * sb._mspec.mthis );

   return *this;
}

inline
MRAsbBase& MRAsbBase::append( MRAsbBase& sb, MRAcrange crange ) 
{
//this should becom part of class
   int (*castc)( bytepack );
   if ( _datatypecode == DataTypeCode_type<float>::code() ) {
      castc = castc_float;
   } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
      castc = castc_double;
   } else {
      castc = 0;
   }

   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _mpenc != sb._mpenc ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _sbn != sb._sbn ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
//   if ( !connected( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
//   if ( !disjoint( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
   if ( _datatypecode != sb._datatypecode ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_sizeb != sb._process_sizeb) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_method != sb._process_method) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   for( int i = 0; i < _process_sizeb - 3; ++i ) {
      if ( _process[i] != sb._process[i] ) {
         clrstate(goodbit), setstate(failbit);
         return *this;
      }
   }
  
   unfix_sb();

//   MRAmlevel mlevel( _mpenc.grid_dim() );
//   MRAmp mp;
//   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
//      mp = *iter;
//      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
//      if ( mlevel <= mrange ) append(mp);
//   }

   MRAmlevel mlevel( _mpenc.grid_dim() );
   MRAmp mp;
   MRAmp mp2(_mpenc);
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      mp2 = mp;
      mp2.set_empty();
      mp2.fix_hdr();
      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);

      MRAacoef acoef;
      MRAclevel clevel;
      for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
         acoef = *itmp;
//         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
//              << castc(acoef.bpcoef) << endl;
         clevel = castc(acoef.bpcoef);
         if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
      }

      mp2.fix_mp();

      append(mp2);
   }


   fix_sb();

//   set_mspec( _mspec.mthis + mrange * sb._mspec.mthis );
   set_cspec( _cspec.cthis + crange * sb._cspec.cthis );

   return *this;
}

inline
MRAsbBase& MRAsbBase::append(MRAsbBase& sb, MRAmrange mrange, MRAcrange crange) 
{
//this should becom part of class
   int (*castc)( bytepack );
   if ( _datatypecode == DataTypeCode_type<float>::code() ) {
      castc = castc_float;
   } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
      castc = castc_double;
   } else {
      castc = 0;
   }

   if ( !sb.good() ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _mpenc != sb._mpenc ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _sbn != sb._sbn ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
//   if ( !connected( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
//   if ( !disjoint( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
//      clrstate(goodbit), setstate(failbit); setstate(fragbit);
//      return *this;
//   }
   if ( _datatypecode != sb._datatypecode ) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_sizeb != sb._process_sizeb) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   if ( _process_method != sb._process_method) {
      clrstate(goodbit), setstate(failbit);
      return *this;
   }
   for( int i = 0; i < _process_sizeb - 3; ++i ) {
      if ( _process[i] != sb._process[i] ) {
         clrstate(goodbit), setstate(failbit);
         return *this;
      }
   }
  
   unfix_sb();

//   MRAmlevel mlevel( _mpenc.grid_dim() );
//   MRAmp mp;
//   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
//      mp = *iter;
//      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
//      if ( mlevel <= mrange ) append(mp);
//   }
   MRAmlevel mlevel( _mpenc.grid_dim() );
   MRAmp mp;
   MRAmp mp2(_mpenc);
   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
      mp = *iter;
      mp2 = mp;
      mp2.set_empty();
      mp2.fix_hdr();
      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
      if ( mlevel <= mrange ) {
         MRAacoef acoef;
         MRAclevel clevel;
         for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
         acoef = *itmp;
//         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
//              << castc(acoef.bpcoef) << endl;
            clevel = castc(acoef.bpcoef);
            if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
         }

         mp2.fix_mp();

         append(mp2);
      }
   }


   fix_sb();

   set_mspec( _mspec.mthis + mrange * sb._mspec.mthis );
   set_cspec( _cspec.cthis + crange * sb._cspec.cthis );

   return *this;
}

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

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

inline
void MRAsbBase::synchronize()
{
   bytepack bp;
   int buffersizeb = _ptbuffer->size();
   _ptbuffer->seekg(0);
   _ptbuffer->read( bp(0,4) ); _sbsizeb = int(bp);
   if ( buffersizeb <= 8 ) { set_null(); }
   else {
      *_ptbuffer >> _mpenc;

      _sbn( _mpenc.grid_dim() );
      *_ptbuffer >> _sbn;

      _mspec( _mpenc.grid_dim() );
      *_ptbuffer >> _mspec;

      *_ptbuffer >> _cspec;

      _ptbuffer->read( bp(0,1) ); _datatypecode = int(bp);
      _ptbuffer->read( bp(0,1) ); _process_sizeb = int(bp);
      _ptbuffer->read( bp(0,1) ); _process_method = int(bp);
      for( int i = 0; i < _process_sizeb - 3; ++i ) 
         _process[i] = _ptbuffer->get();
      _ptbuffer->read( bp(0,1) );
      if ( _sbsizeb == -1 ) {
         int markp = _ptbuffer->tellp();
         int markg = _ptbuffer->tellg();
         _ptbuffer->seekg(-4,BufferBase::end);
         _ptbuffer->read( bp(0,4) ); _sbsizeb = int(bp);
         _ptbuffer->seekp(markp);
         _ptbuffer->seekg(markg);
      }
   }
}

// ##### MRAsbBase::iterator #####

inline
MRAsbBase::iterator::iterator( MRAsbBase* ptsb ) 
  : _pos(0), _ptsb(ptsb)
{}

inline
MRAsbBase::iterator::~iterator() { _ptsb = 0; }

inline
MRAsbBase::iterator& MRAsbBase::iterator::operator ++ ()
{ 
   if ( !is_null() ) {
      MRAmp mp( _ptsb->_mpenc );
      int tmppos = _ptsb->_ptbuffer->tellg();
      _ptsb->_ptbuffer->seekg(_pos);
      mp.write( *(_ptsb->_ptbuffer) );
      _pos = _ptsb->_ptbuffer->tellg();
      _ptsb->_ptbuffer->seekg(tmppos);
   }
   return *this; 
}

inline
MRAmp MRAsbBase::iterator::operator * () 
{ 
   MRAmp mp;
   if ( !is_null() ) {
      mp( _ptsb->_mpenc );
      int tmppos = _ptsb->_ptbuffer->tellg();
      _ptsb->_ptbuffer->seekg(_pos);
      mp.write( *(_ptsb->_ptbuffer) );
      _ptsb->_ptbuffer->seekg(tmppos);
   }
   return mp; 
}

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

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

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

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

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

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

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

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

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

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

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

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

inline
BufferBase& operator << ( BufferBase& buffer, MRAsbBase& sb ) 
{
   sb.read(buffer);
   return buffer;
}

inline
BufferBase& operator>>( BufferBase& buffer, MRAsbBase& sb )
{
   sb.write(buffer);
   return buffer;
}

inline
ostream& operator << ( ostream& os, MRAsbBase& sb ) 
{
   sb.read(os);
   return os;
}

inline
istream& operator>>( istream& is, MRAsbBase& sb )
{
   sb.write(is);
   return is;
}

#endif

---