Main Page | Class Hierarchy | Alphabetical List | Data Structures | File List | Data Fields | Globals

MRAsbBase Class Reference

#include <MRAsbBase.h>

Inheritance diagram for MRAsbBase:

Inheritance graph
[legend]
Collaboration diagram for MRAsbBase:

Collaboration graph
[legend]

Public Member Functions

MRAsbBase & append (MRAsbBase &, MRAmrange, MRAcrange)
MRAsbBase & append (MRAsbBase &, MRAcrange)
MRAsbBase & append (MRAsbBase &, MRAmrange)
MRAsbBase & append (MRAsbBase &)
MRAsbBase & append (MRAmpBase &)
MRAsbBase & append_null ()
bool baddim ()
iterator begin ()
void clear ()
void clrstate (int)
MRAsbBase & copy (MRAsbBase &, MRAmrange, MRAcrange)
MRAsbBase & copy (MRAsbBase &, MRAcrange)
MRAsbBase & copy (MRAsbBase &, MRAmrange)
MRAsbBase & copy (const MRAsbBase &)
MRAcspec & cspec ()
int datatypecode ()
iterator end ()
bool fail ()
void fix_hdr ()
void fix_sb ()
bool frag ()
bool good ()
bool hdrfixed ()
int hdrsizeb ()
bool is_empty ()
bool is_equal (const MRAsbBase &)
bool is_null ()
virtual string isa () const
bool mmatch (MRAmrange, MRAmpBase &)
MRAmpEncode & mpenc ()
 MRAsbBase (const MRAmpEncode &, BufferBase *)
 MRAsbBase (const MRAsbBase &, BufferBase *)
 MRAsbBase (BufferBase *)
MRAmspec & mspec ()
bool operator! ()
bool operator!= (const MRAsbBase &)
MRAsbBase & operator() (const MRAmpEncode &, BufferBase *)
MRAsbBase & operator() (const MRAsbBase &, BufferBase *)
MRAsbBase & operator() (BufferBase *)
MRAsbBase & operator<< (BufferBase &)
MRAsbBase & operator= (const MRAsbBase &)
bool operator== (const MRAsbBase &)
MRAsbBase & operator>> (BufferBase &)
char process (int i)
char * process ()
int process_method ()
int process_sizeb ()
int rdstate (int=0xFF)
void read (ostream &)
void read (BufferBase &)
void recover (istream &)
void recover (BufferBase &)
void refix_hdr ()
bool sbfixed ()
MRAsbn & sbn ()
int sbsizeb ()
void set_cspec (const MRAcrange &cthis)
void set_cspec (const MRAcrange &cthis, const MRAcrange &cexist, const MRAcrange &ctheory)
void set_cspec (const MRAcspec &)
void set_cspec ()
void set_datatypecode (int datatypecode)
MRAsbBase & set_empty ()
void set_mspec (const MRAmrange &mthis)
void set_mspec (const MRAmrange &mthis, const MRAmrange &mexist, const MRAmrange &mtheory)
void set_mspec (const MRAmspec &)
void set_mspec ()
MRAsbBase & set_null ()
void set_sbn (int sbn)
void set_sbn (const MRAsbn &)
void set_sbn ()
void setstate (int)
void unfix_sb ()
void write (istream &)
void write (BufferBase &)
virtual ~MRAsbBase ()

Static Public Attributes

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

Protected Attributes

MRAcspec _cspec
int _datatypecode
MRAmpEncode _mpenc
MRAmspec _mspec
char _process [MRASBBASE_PROCESS_MAXSIZEB]
int _process_method
int _process_sizeb
BufferBase * _ptbuffer
MRAsbn _sbn
int _sbsizeb
int _state

Private Member Functions

 MRAsbBase ()
virtual void synchronize ()

Friends

class iterator
class MRAsbObject
ostream & operator<< (ostream &, MRAsbBase &)
BufferBase & operator<< (BufferBase &, MRAsbBase &)
istream & operator>> (istream &, MRAsbBase &)
BufferBase & operator>> (BufferBase &, MRAsbBase &)

Constructor & Destructor Documentation

MRAsbBase::MRAsbBase (  BufferBase *   ) 
 

Definition at line 224 of file MRAsbBase.h.

References BufferBase.erase(), and set_null(). 

00225   : _ptbuffer(ptbuffer)
00226 {
00227    set_null();
00228    _ptbuffer->erase();
00229 }

MRAsbBase::MRAsbBase (  const MRAsbBase &  ,
BufferBase * 
) 
 

Definition at line 232 of file MRAsbBase.h.

References _process, _ptbuffer, BufferBase.get(), process_sizeb(), BufferBase.put(), BufferBase.seekg(), BufferBase.seekp(), and BufferBase.size(). 

00233   : _state(sb._state), _mpenc(sb._mpenc),
00234     _sbsizeb(sb._sbsizeb),
00235     _sbn(sb._sbn), _mspec(sb._mspec), _cspec(sb._cspec),
00236     _datatypecode(sb._datatypecode),
00237     _process_sizeb(sb._process_sizeb), _process_method(sb._process_method),
00238     _ptbuffer(ptbuffer)
00239 {
00240    
00241    for( int i = 0; i < process_sizeb(); ++i ) _process[i] = sb._process[i];
00242    sb._ptbuffer->seekg(0);
00243    _ptbuffer->seekp(0);
00244    for( int i = 0; i < sb._ptbuffer->size(); ++i ) {
00245       _ptbuffer->put( sb._ptbuffer->get() );
00246    }
00247 }

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

Definition at line 250 of file MRAsbBase.h. 

00251   : _state(goodbit), _mpenc(mpenc), 
00252     _sbsizeb(0), 
00253     _sbn( _mpenc.grid_dim() ), _mspec( _mpenc.grid_dim() ), 
00254     _datatypecode(0),
00255     _process_sizeb(3), _process_method(0),
00256     _ptbuffer(ptbuffer)
00257 {}

MRAsbBase::~MRAsbBase (   )  [virtual]
 

Definition at line 260 of file MRAsbBase.h. 

00261 {
00262    if ( _ptbuffer != 0 ) { delete _ptbuffer; _ptbuffer = 0; }
00263 }

MRAsbBase.MRAsbBase (   )  [private]
 

Definition at line 208 of file MRAsbBase.h. 

00208 {}

Member Function Documentation

MRAsbBase & MRAsbBase::append (  MRAsbBase &  ,
MRAmrange  ,
MRAcrange 
) 
 

Definition at line 1343 of file MRAsbBase.h.

References _cspec, _datatypecode, _mpenc, _mspec, _process, _process_method, _process_sizeb, _sbn, MRAacoef.a, append(), MRAmpBase.append(), begin(), MRAacoef.bpcoef, castc_double(), castc_float(), clrstate(), DataTypeCode_type< Type >.code(), MRAcspec.cthis, end(), MRAmpBase.fix_hdr(), MRAmpBase.fix_mp(), fix_sb(), good(), MRAmpEncode.grid_dim(), MRAmspec.mthis, set_cspec(), MRAmpBase.set_empty(), set_mspec(), setstate(), and unfix_sb(). 

01344 {
01345 //this should becom part of class
01346    int (*castc)( bytepack );
01347    if ( _datatypecode == DataTypeCode_type<float>::code() ) {
01348       castc = castc_float;
01349    } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
01350       castc = castc_double;
01351    } else {
01352       castc = 0;
01353    }
01354 
01355    if ( !sb.good() ) {
01356       clrstate(goodbit), setstate(failbit);
01357       return *this;
01358    }
01359    if ( _mpenc != sb._mpenc ) {
01360       clrstate(goodbit), setstate(failbit);
01361       return *this;
01362    }
01363    if ( _sbn != sb._sbn ) {
01364       clrstate(goodbit), setstate(failbit);
01365       return *this;
01366    }
01367 //   if ( !connected( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
01368 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01369 //      return *this;
01370 //   }
01371 //   if ( !disjoint( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
01372 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01373 //      return *this;
01374 //   }
01375    if ( _datatypecode != sb._datatypecode ) {
01376       clrstate(goodbit), setstate(failbit);
01377       return *this;
01378    }
01379    if ( _process_sizeb != sb._process_sizeb) {
01380       clrstate(goodbit), setstate(failbit);
01381       return *this;
01382    }
01383    if ( _process_method != sb._process_method) {
01384       clrstate(goodbit), setstate(failbit);
01385       return *this;
01386    }
01387    for( int i = 0; i < _process_sizeb - 3; ++i ) {
01388       if ( _process[i] != sb._process[i] ) {
01389          clrstate(goodbit), setstate(failbit);
01390          return *this;
01391       }
01392    }
01393   
01394    unfix_sb();
01395 
01396 //   MRAmlevel mlevel( _mpenc.grid_dim() );
01397 //   MRAmp mp;
01398 //   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
01399 //      mp = *iter;
01400 //      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
01401 //      if ( mlevel <= mrange ) append(mp);
01402 //   }
01403    MRAmlevel mlevel( _mpenc.grid_dim() );
01404    MRAmp mp;
01405    MRAmp mp2(_mpenc);
01406    for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
01407       mp = *iter;
01408       mp2 = mp;
01409       mp2.set_empty();
01410       mp2.fix_hdr();
01411       for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
01412       if ( mlevel <= mrange ) {
01413          MRAacoef acoef;
01414          MRAclevel clevel;
01415          for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
01416          acoef = *itmp;
01417 //         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
01418 //              << castc(acoef.bpcoef) << endl;
01419             clevel = castc(acoef.bpcoef);
01420             if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
01421          }
01422 
01423          mp2.fix_mp();
01424 
01425          append(mp2);
01426       }
01427    }
01428 
01429 
01430    fix_sb();
01431 
01432    set_mspec( _mspec.mthis + mrange * sb._mspec.mthis );
01433    set_cspec( _cspec.cthis + crange * sb._cspec.cthis );
01434 
01435    return *this;
01436 }

MRAsbBase & MRAsbBase::append (  MRAsbBase &  ,
MRAcrange 
) 
 

Definition at line 1247 of file MRAsbBase.h.

References _cspec, _datatypecode, _mpenc, _process, _process_method, _process_sizeb, _sbn, MRAacoef.a, append(), MRAmpBase.append(), begin(), MRAacoef.bpcoef, castc_double(), castc_float(), clrstate(), DataTypeCode_type< Type >.code(), MRAcspec.cthis, end(), MRAmpBase.fix_hdr(), MRAmpBase.fix_mp(), fix_sb(), good(), MRAmpEncode.grid_dim(), set_cspec(), MRAmpBase.set_empty(), setstate(), and unfix_sb(). 

01248 {
01249 //this should becom part of class
01250    int (*castc)( bytepack );
01251    if ( _datatypecode == DataTypeCode_type<float>::code() ) {
01252       castc = castc_float;
01253    } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
01254       castc = castc_double;
01255    } else {
01256       castc = 0;
01257    }
01258 
01259    if ( !sb.good() ) {
01260       clrstate(goodbit), setstate(failbit);
01261       return *this;
01262    }
01263    if ( _mpenc != sb._mpenc ) {
01264       clrstate(goodbit), setstate(failbit);
01265       return *this;
01266    }
01267    if ( _sbn != sb._sbn ) {
01268       clrstate(goodbit), setstate(failbit);
01269       return *this;
01270    }
01271 //   if ( !connected( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
01272 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01273 //      return *this;
01274 //   }
01275 //   if ( !disjoint( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
01276 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01277 //      return *this;
01278 //   }
01279    if ( _datatypecode != sb._datatypecode ) {
01280       clrstate(goodbit), setstate(failbit);
01281       return *this;
01282    }
01283    if ( _process_sizeb != sb._process_sizeb) {
01284       clrstate(goodbit), setstate(failbit);
01285       return *this;
01286    }
01287    if ( _process_method != sb._process_method) {
01288       clrstate(goodbit), setstate(failbit);
01289       return *this;
01290    }
01291    for( int i = 0; i < _process_sizeb - 3; ++i ) {
01292       if ( _process[i] != sb._process[i] ) {
01293          clrstate(goodbit), setstate(failbit);
01294          return *this;
01295       }
01296    }
01297   
01298    unfix_sb();
01299 
01300 //   MRAmlevel mlevel( _mpenc.grid_dim() );
01301 //   MRAmp mp;
01302 //   for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
01303 //      mp = *iter;
01304 //      for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
01305 //      if ( mlevel <= mrange ) append(mp);
01306 //   }
01307 
01308    MRAmlevel mlevel( _mpenc.grid_dim() );
01309    MRAmp mp;
01310    MRAmp mp2(_mpenc);
01311    for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
01312       mp = *iter;
01313       mp2 = mp;
01314       mp2.set_empty();
01315       mp2.fix_hdr();
01316       for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
01317 
01318       MRAacoef acoef;
01319       MRAclevel clevel;
01320       for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
01321          acoef = *itmp;
01322 //         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
01323 //              << castc(acoef.bpcoef) << endl;
01324          clevel = castc(acoef.bpcoef);
01325          if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
01326       }
01327 
01328       mp2.fix_mp();
01329 
01330       append(mp2);
01331    }
01332 
01333 
01334    fix_sb();
01335 
01336 //   set_mspec( _mspec.mthis + mrange * sb._mspec.mthis );
01337    set_cspec( _cspec.cthis + crange * sb._cspec.cthis );
01338 
01339    return *this;
01340 }

MRAsbBase & MRAsbBase::append (  MRAsbBase &  ,
MRAmrange 
) 
 

Definition at line 1188 of file MRAsbBase.h.

References _datatypecode, _mpenc, _mspec, _process, _process_method, _process_sizeb, _sbn, append(), begin(), clrstate(), end(), fix_sb(), good(), MRAmpEncode.grid_dim(), MRAmpBase.mcode_to_m(), MRAmspec.mthis, set_mspec(), setstate(), and unfix_sb(). 

01189 {
01190    if ( !sb.good() ) {
01191       clrstate(goodbit), setstate(failbit);
01192       return *this;
01193    }
01194    if ( _mpenc != sb._mpenc ) {
01195       clrstate(goodbit), setstate(failbit);
01196       return *this;
01197    }
01198    if ( _sbn != sb._sbn ) {
01199       clrstate(goodbit), setstate(failbit);
01200       return *this;
01201    }
01202 //   if ( !connected( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
01203 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01204 //      return *this;
01205 //   }
01206 //   if ( !disjoint( _mspec.mthis, mrange*sb._mspec.mthis ) ) {
01207 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01208 //      return *this;
01209 //   }
01210    if ( _datatypecode != sb._datatypecode ) {
01211       clrstate(goodbit), setstate(failbit);
01212       return *this;
01213    }
01214    if ( _process_sizeb != sb._process_sizeb) {
01215       clrstate(goodbit), setstate(failbit);
01216       return *this;
01217    }
01218    if ( _process_method != sb._process_method) {
01219       clrstate(goodbit), setstate(failbit);
01220       return *this;
01221    }
01222    for( int i = 0; i < _process_sizeb - 3; ++i ) {
01223       if ( _process[i] != sb._process[i] ) {
01224          clrstate(goodbit), setstate(failbit);
01225          return *this;
01226       }
01227    }
01228   
01229    unfix_sb();
01230 
01231    MRAmlevel mlevel( _mpenc.grid_dim() );
01232    MRAmp mp;
01233    for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
01234       mp = *iter;
01235       for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
01236       if ( mlevel <= mrange ) append(mp);
01237    }
01238 
01239    fix_sb();
01240 
01241    set_mspec( _mspec.mthis + mrange * sb._mspec.mthis );
01242 
01243    return *this;
01244 }

MRAsbBase & MRAsbBase::append (  MRAsbBase &   ) 
 

Definition at line 1131 of file MRAsbBase.h.

References _datatypecode, _mpenc, _mspec, _process, _process_method, _process_sizeb, _sbn, append(), begin(), clrstate(), end(), fix_sb(), good(), MRAmspec.mthis, set_mspec(), setstate(), and unfix_sb(). 

01132 {
01133    if ( !sb.good() ) {
01134       clrstate(goodbit), setstate(failbit);
01135       return *this;
01136    }
01137    if ( _mpenc != sb._mpenc ) {
01138       clrstate(goodbit), setstate(failbit);
01139       return *this;
01140    }
01141    if ( _sbn != sb._sbn ) {
01142       clrstate(goodbit), setstate(failbit);
01143       return *this;
01144    }
01145 //   if ( !connected( _mspec.mthis, sb._mspec.mthis ) ) {
01146 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01147 //      return *this;
01148 //   }
01149 //   if ( !disjoint( _mspec.mthis, sb._mspec.mthis ) ) {
01150 //      clrstate(goodbit), setstate(failbit); setstate(fragbit);
01151 //      return *this;
01152 //   }
01153    if ( _datatypecode != sb._datatypecode ) {
01154       clrstate(goodbit), setstate(failbit);
01155       return *this;
01156    }
01157    if ( _process_sizeb != sb._process_sizeb) {
01158       clrstate(goodbit), setstate(failbit);
01159       return *this;
01160    }
01161    if ( _process_method != sb._process_method) {
01162       clrstate(goodbit), setstate(failbit);
01163       return *this;
01164    }
01165    for( int i = 0; i < _process_sizeb - 3; ++i ) {
01166       if ( _process[i] != sb._process[i] ) {
01167          clrstate(goodbit), setstate(failbit);
01168          return *this;
01169       }
01170    }
01171  
01172    unfix_sb();
01173 
01174    MRAmp mp;
01175    for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
01176       mp = *iter;
01177       append(mp);
01178    }
01179 
01180    fix_sb();
01181 
01182    set_mspec( _mspec.mthis + sb._mspec.mthis );
01183 
01184    return *this;
01185 }

MRAsbBase & MRAsbBase::append (  MRAmpBase &   ) 
 

Definition at line 1104 of file MRAsbBase.h.

References _sbsizeb, hdrfixed(), MRAmpBase.mpenc(), MRAmpBase.mpsizeb(), MRAmpBase.read(), sbfixed(), and setstate().

Referenced by MRAsbObject.append(), append(), copy(), and MRAsbObject.create_clone(). 

01105 {
01106    if ( hdrfixed() && !sbfixed() ) {
01107       if ( _mpenc == mp.mpenc() ) {
01108          mp.read( *_ptbuffer );
01109          _sbsizeb += mp.mpsizeb();
01110       }
01111       else { setstate(failbit); }
01112    }
01113    else { setstate(failbit); }
01114    return *this;
01115 }

MRAsbBase & MRAsbBase::append_null (   ) 
 

Definition at line 1118 of file MRAsbBase.h.

References _sbsizeb, hdrfixed(), mpenc(), MRAmpBase.nullsizeb(), MRAmpBase.read(), sbfixed(), MRAmpBase.set_null(), and setstate().

Referenced by fix_sb(). 

01119 {
01120    if ( hdrfixed() && !sbfixed() ) {
01121       MRAmp mp( mpenc() );
01122       mp.set_null();
01123       mp.read( *_ptbuffer ); 
01124       _sbsizeb += mp.nullsizeb();
01125    }
01126    else { setstate(failbit); }
01127    return *this;
01128 }

bool MRAsbBase::baddim (   ) 
 

Definition at line 627 of file MRAsbBase.h.

References rdstate(). 

00627 { return rdstate(baddimbit) != 0; }

MRAsbBase::iterator MRAsbBase::begin (   ) 
 

Definition at line 1439 of file MRAsbBase.h.

References MRAsbBase.iterator._pos, hdrfixed(), hdrsizeb(), sbfixed(), and MRAsbBase.iterator.set_null().

Referenced by append(), copy(), MRAsbObject.cstattable_sbsizeb(), and MRAsbObject.mstattable_sbsizeb(). 

01440 {
01441    iterator iter(this);
01442    if ( hdrfixed() && sbfixed() ) {
01443       iter._pos = hdrsizeb();
01444    } else {
01445       iter.set_null();
01446    }
01447    return iter;
01448 }

void MRAsbBase::clear (   ) 
 

Definition at line 609 of file MRAsbBase.h.

Referenced by copy(), set_empty(), and write(). 

00609 { _state = goodbit; }

void MRAsbBase::clrstate (  int   ) 
 

Definition at line 615 of file MRAsbBase.h.

Referenced by append(), copy(), and unfix_sb(). 

00615 { _state &= ~s; }

MRAsbBase & MRAsbBase::copy (  MRAsbBase &  ,
MRAmrange  ,
MRAcrange 
) 
 

Definition at line 511 of file MRAsbBase.h.

References _datatypecode, _mpenc, _process, _process_method, _process_sizeb, _sbsizeb, MRAacoef.a, append(), MRAmpBase.append(), begin(), MRAacoef.bpcoef, castc_double(), castc_float(), clear(), clrstate(), DataTypeCode_type< Type >.code(), cspec(), MRAcspec.cthis, datatypecode(), end(), MRAmpBase.fix_hdr(), fix_hdr(), MRAmpBase.fix_mp(), fix_sb(), good(), MRAmpEncode.grid_dim(), mspec(), process(), process_method(), process_sizeb(), sbn(), set_cspec(), set_datatypecode(), MRAmpBase.set_empty(), set_mspec(), set_sbn(), and setstate(). 

00512 {
00513 //this should becom part of class
00514    int (*castc)( bytepack );
00515    if ( _datatypecode == DataTypeCode_type<float>::code() ) {
00516       castc = castc_float;
00517 cout << "cast as float\n";
00518    } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
00519       castc = castc_double;
00520 cout << "cast as double\n";
00521    } else {
00522       castc = 0;
00523    }
00524 
00525    if ( !sb.good() ) {
00526       clrstate(goodbit), setstate(failbit);
00527       return *this;
00528    }
00529    clear();
00530    _mpenc = sb._mpenc;
00531    _sbsizeb = 0;
00532    set_sbn( sb.sbn() );
00533    set_mspec( sb.mspec() );
00534    set_cspec( sb.cspec() );
00535    set_cspec( crange * sb.cspec().cthis );
00536    set_datatypecode( sb.datatypecode() );
00537    _process_sizeb = sb.process_sizeb();
00538    _process_method = sb.process_method();
00539    for(int i = 0; i < _process_sizeb - 3; ++i ) { _process[i] = sb.process(i);} 
00540    fix_hdr();
00541 
00542    MRAmlevel mlevel( _mpenc.grid_dim() );
00543    MRAmp mp;
00544    MRAmp mp2(_mpenc);
00545    for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
00546       mp = *iter;
00547       mp2 = mp;
00548       mp2.set_empty();
00549       mp2.fix_hdr();
00550       for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
00551       if ( mlevel <= mrange ) {
00552          MRAacoef acoef;
00553          MRAclevel clevel;
00554          for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
00555          acoef = *itmp;
00556 //         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
00557 //              << castc(acoef.bpcoef) << endl;
00558             clevel = castc(acoef.bpcoef);
00559             if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
00560          }
00561 
00562          mp2.fix_mp();
00563 
00564          append(mp2);
00565       }
00566    }
00567 
00568    fix_sb();
00569 
00570    return *this;
00571 }

MRAsbBase & MRAsbBase::copy (  MRAsbBase &  ,
MRAcrange 
) 
 

Definition at line 451 of file MRAsbBase.h.

References _datatypecode, _mpenc, _process, _process_method, _process_sizeb, _sbsizeb, MRAacoef.a, append(), MRAmpBase.append(), begin(), MRAacoef.bpcoef, castc_double(), castc_float(), clear(), clrstate(), DataTypeCode_type< Type >.code(), cspec(), MRAcspec.cthis, datatypecode(), end(), MRAmpBase.fix_hdr(), fix_hdr(), MRAmpBase.fix_mp(), fix_sb(), good(), MRAmpEncode.grid_dim(), mspec(), process(), process_method(), process_sizeb(), sbn(), set_cspec(), set_datatypecode(), MRAmpBase.set_empty(), set_mspec(), set_sbn(), and setstate(). 

00452 {
00453 //this should becom part of class
00454    int (*castc)( bytepack );
00455    if ( _datatypecode == DataTypeCode_type<float>::code() ) {
00456       castc = castc_float;
00457    } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
00458       castc = castc_double;
00459    } else {
00460       castc = 0;
00461    }
00462 
00463    if ( !sb.good() ) {
00464       clrstate(goodbit), setstate(failbit);
00465       return *this;
00466    }
00467    clear();
00468    _mpenc = sb._mpenc;
00469    _sbsizeb = 0;
00470    set_sbn( sb.sbn() );
00471    set_mspec( sb.mspec() );
00472    set_cspec( sb.cspec() );
00473    set_cspec( crange * sb.cspec().cthis );
00474    set_datatypecode( sb.datatypecode() );
00475    _process_sizeb = sb.process_sizeb();
00476    _process_method = sb.process_method();
00477    for(int i = 0; i < _process_sizeb - 3; ++i ) { _process[i] = sb.process(i);} 
00478    fix_hdr();
00479 
00480    MRAmlevel mlevel( _mpenc.grid_dim() );
00481    MRAmp mp;
00482    MRAmp mp2(_mpenc);
00483    for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
00484       mp = *iter;
00485       mp2 = mp;
00486       mp2.set_empty();
00487       mp2.fix_hdr();
00488       for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
00489 
00490       MRAacoef acoef;
00491       MRAclevel clevel;
00492       for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
00493          acoef = *itmp;
00494 //         cout << "   " << acoef.a[0] << ":" << float(acoef.bpcoef)  << ' ' 
00495 //              << castc(acoef.bpcoef) << endl;
00496          clevel = castc(acoef.bpcoef);
00497          if ( clevel <= crange ) mp2.append( acoef.a, acoef.bpcoef );
00498       }
00499 
00500       mp2.fix_mp();
00501 
00502       append(mp2);
00503    }
00504 
00505    fix_sb();
00506 
00507    return *this;
00508 }

MRAsbBase & MRAsbBase::copy (  MRAsbBase &  ,
MRAmrange 
) 
 

Definition at line 346 of file MRAsbBase.h.

References _mpenc, _process, _process_method, _process_sizeb, _sbsizeb, append(), begin(), clear(), clrstate(), cspec(), datatypecode(), end(), fix_hdr(), fix_sb(), good(), MRAmpEncode.grid_dim(), MRAmpBase.mcode_to_m(), mspec(), MRAmspec.mthis, process(), process_method(), process_sizeb(), sbn(), set_cspec(), set_datatypecode(), set_mspec(), set_sbn(), and setstate(). 

00347 {
00348    if ( !sb.good() ) {
00349       clrstate(goodbit), setstate(failbit);
00350       return *this;
00351    }
00352    clear();
00353    _mpenc = sb._mpenc;
00354    _sbsizeb = 0;
00355    set_sbn( sb.sbn() );
00356    set_mspec( sb.mspec() );
00357    set_mspec( mrange * sb.mspec().mthis );
00358    set_cspec( sb.cspec() );
00359    set_datatypecode( sb.datatypecode() );
00360    _process_sizeb = sb.process_sizeb();
00361    _process_method = sb.process_method();
00362    for( int i = 0; i < _process_sizeb - 3; ++i ) {
00363       _process[i] = sb.process(i);
00364    }
00365  
00366    fix_hdr();
00367 
00368    MRAmlevel mlevel( _mpenc.grid_dim() );
00369    MRAmp mp;
00370    for( MRAsbBase::iterator iter = sb.begin(); iter < sb.end(); ++iter ) {
00371       mp = *iter;
00372       for(int d=0; d < _mpenc.grid_dim(); ++d) mlevel[d] = mp.mcode_to_m(d);
00373       if ( mlevel <= mrange ) append(mp);
00374    }
00375 
00376    fix_sb();
00377 
00378    return *this;
00379 }

MRAsbBase & MRAsbBase::copy (  const MRAsbBase &   ) 
 

Definition at line 318 of file MRAsbBase.h.

References _cspec, _datatypecode, _mpenc, _mspec, _process, _process_method, _process_sizeb, _ptbuffer, _sbn, _sbsizeb, _state, BufferBase.get(), MRAmpEncode.grid_dim(), process_sizeb(), BufferBase.put(), BufferBase.seekg(), BufferBase.seekp(), and BufferBase.size().

Referenced by MRAsbObject.create_clone(), operator=(), and MRAsbObject.store(). 

00319 {
00320    if ( this != &sb ) {
00321       _state = sb._state;
00322       _mpenc = sb._mpenc;
00323       _sbsizeb = sb._sbsizeb;
00324       _sbn( _mpenc.grid_dim() ) = sb._sbn;
00325       _mspec( _mpenc.grid_dim() ) = sb._mspec;
00326       _cspec = sb._cspec;
00327       _datatypecode = sb._datatypecode;
00328       _process_sizeb = sb._process_sizeb;
00329       _process_method = sb._process_method;
00330       for( int i = 0; i < process_sizeb(); ++i ) _process[i]=sb._process[i];
00331       sb._ptbuffer->seekg(0);
00332       _ptbuffer->seekp(0);
00333       char c;
00334       for( int i = 0; i < sb._ptbuffer->size(); ++i ) {
00335          c = sb._ptbuffer->get();
00336          _ptbuffer->put( c );
00337       }
00338    }
00339    return *this;
00340 }

MRAcspec & MRAsbBase::cspec (   ) 
 

Definition at line 1070 of file MRAsbBase.h.

Referenced by MRAsbObject.append(), copy(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), MRAsbObject.set_empty(), and MRAsbObject.store(). 

01070 { return _cspec; }

int MRAsbBase::datatypecode (   ) 
 

Definition at line 1073 of file MRAsbBase.h.

References _datatypecode.

Referenced by copy(), and MRAsbObject.store(). 

01073 { return _datatypecode; }

MRAsbBase::iterator MRAsbBase::end (   ) 
 

Definition at line 1451 of file MRAsbBase.h.

References MRAsbBase.iterator._pos, _sbsizeb, MRAmpEncode.bplen_mpsizeb(), hdrfixed(), sbfixed(), and MRAsbBase.iterator.set_null().

Referenced by append(), and copy(). 

01452 {
01453    iterator iter(this);
01454    if ( hdrfixed() && sbfixed() ) {
01455       iter._pos = _sbsizeb - 4 - _mpenc.bplen_mpsizeb() * 2;
01456    }  else {
01457       iter.set_null();
01458    }
01459    return iter;
01460 }

bool MRAsbBase::fail (   ) 
 

Definition at line 624 of file MRAsbBase.h.

References rdstate(). 

00624 { return rdstate(failbit) != 0; }

void MRAsbBase::fix_hdr (   ) 
 

Definition at line 670 of file MRAsbBase.h.

References _datatypecode, _process, _process_method, _process_sizeb, _sbsizeb, hdrfixed(), hdrsizeb(), process_sizeb(), BufferBase.put(), BufferBase.seekp(), setstate(), and BufferBase.write().

Referenced by copy(), and set_empty(). 

00670                         { 
00671    if ( !hdrfixed() ) {
00672       bytepack bp;
00673       setstate(hdrfixedbit);
00674       _sbsizeb = hdrsizeb();
00675       _ptbuffer->seekp(0);
00676       _ptbuffer->write( bp( 0, 4 ) );
00677 
00678       *_ptbuffer << _mpenc;
00679       *_ptbuffer << _sbn;
00680       *_ptbuffer << _mspec;
00681       *_ptbuffer << _cspec;
00682 
00683       _ptbuffer->write( bp( _datatypecode, 1 ) );
00684       _ptbuffer->write( bp( _process_sizeb, 1 ) );
00685       _ptbuffer->write( bp( _process_method, 1 ) );
00686       for( int i = 0; i < _process_sizeb - 3; ++i ) {
00687          _ptbuffer->put( _process[i] );
00688       }
00689       _ptbuffer->write( bp( process_sizeb(), 1 ) );
00690    }
00691    else { setstate(failbit); }
00692 }

void MRAsbBase::fix_sb (   ) 
 

Definition at line 695 of file MRAsbBase.h.

References _sbsizeb, append_null(), hdrfixed(), sbfixed(), sbfixedbit, BufferBase.seekp(), setstate(), and BufferBase.write().

Referenced by append(), copy(), and set_empty(). 

00696 {
00697    if ( hdrfixed() && !sbfixed() ) {
00698       bytepack bp;
00699       append_null();
00700       setstate(sbfixedbit);
00701       _sbsizeb += 4;
00702       _ptbuffer->write( bp( _sbsizeb, 4 ) );
00703       _ptbuffer->seekp(0);
00704       _ptbuffer->write( bp( _sbsizeb, 4 ) );
00705       _ptbuffer->seekp(0,BufferBase::end);
00706    }
00707    else { setstate(failbit); }
00708 }

bool MRAsbBase::frag (   ) 
 

Definition at line 630 of file MRAsbBase.h.

References rdstate(). 

00630 { return rdstate(fragbit) != 0; }

bool MRAsbBase::good (   ) 
 

Definition at line 621 of file MRAsbBase.h.

References rdstate().

Referenced by append(), and copy(). 

00621 { return rdstate(goodbit) != 0; }

bool MRAsbBase::hdrfixed (   ) 
 

Definition at line 633 of file MRAsbBase.h.

References rdstate().

Referenced by append(), append_null(), begin(), end(), fix_hdr(), fix_sb(), refix_hdr(), set_cspec(), set_datatypecode(), set_mspec(), set_sbn(), and unfix_sb(). 

00633 { return rdstate(hdrfixedbit) != 0; }

int MRAsbBase::hdrsizeb (   ) 
 

Definition at line 1088 of file MRAsbBase.h.

References _process_sizeb, MRAcspec.sizeb(), MRAmspec.sizeb(), MRAsbn.sizeb(), and MRAmpEncode.sizeb().

Referenced by begin(), fix_hdr(), and recover(). 

01089 {
01090    return 5 + _mpenc.sizeb() + _sbn.sizeb()
01091             + _mspec.sizeb() + _cspec.sizeb() 
01092             + _process_sizeb;
01093 }

bool MRAsbBase.is_empty (   ) 
 

Referenced by MRAsbObject.is_empty().

bool MRAsbBase::is_equal (  const MRAsbBase &   ) 
 

Definition at line 574 of file MRAsbBase.h.

References _cspec, _datatypecode, _mpenc, _mspec, _process, _process_method, _process_sizeb, _ptbuffer, _sbn, _sbsizeb, _state, BufferBase.get(), process_sizeb(), BufferBase.seekg(), and BufferBase.tellg().

Referenced by operator!=(), and operator==(). 

00575 {
00576    if ( this != &sb ) {
00577       if ( _state != sb._state ) return false;
00578       if ( _mpenc != sb._mpenc ) return false;
00579       if ( _sbsizeb != sb._sbsizeb ) return false;
00580       if ( _sbn != sb._sbn ) return false;
00581       if ( _mspec != sb._mspec ) return false;
00582       if ( _cspec != sb._cspec ) return false;
00583       if ( _datatypecode != sb._datatypecode ) return false;
00584       if ( _process_sizeb != sb._process_sizeb ) return false;
00585       if ( _process_method != sb._process_method ) return false;
00586       for( int i = 0; i < _process_sizeb - 3; ++i ) {
00587          if ( _process[i] != sb._process[i] ) return false;
00588       }
00589       int mark = _ptbuffer->tellg();
00590       int sbmark = sb._ptbuffer->tellg();
00591       _ptbuffer->seekg(0);
00592       sb._ptbuffer->seekg(0);
00593       for( int i = 0; i < process_sizeb() - 3; ++i ) {
00594          if ( _ptbuffer->get() != sb._ptbuffer->get() ) return false;
00595       }
00596       _ptbuffer->seekg(mark);
00597       sb._ptbuffer->seekg(sbmark);
00598    }
00599    return true;
00600 }

bool MRAsbBase::is_null (   ) 
 

Definition at line 654 of file MRAsbBase.h.

References _sbsizeb.

Referenced by operator!(), and read(). 

00654 { return (_sbsizeb == 0); }

virtual string MRAsbBase.isa (   )  const [virtual]
 

Reimplemented in MRAsb.

Definition at line 43 of file MRAsbBase.h.

Referenced by MRAsbObject.synchronize(). 

00043 { return "MRAsbBase"; }

bool MRAsbBase::mmatch (  MRAmrange  ,
MRAmpBase & 
) 
 

Definition at line 1096 of file MRAsbBase.h.

References MRAmpEncode.grid_dim(), and MRAmpBase.mcode_to_m(). 

01097 {
01098    MRAmlevel tmpmlevel( _mpenc.grid_dim() );
01099    for(int d = 0; d < _mpenc.grid_dim(); ++d ) tmpmlevel[d] = mp.mcode_to_m(d);
01100    return ( tmpmlevel <= mrange  );
01101 }

MRAmpEncode & MRAsbBase::mpenc (   ) 
 

Definition at line 1058 of file MRAsbBase.h.

Referenced by append_null(). 

01058 { return _mpenc; }

MRAmspec & MRAsbBase::mspec (   ) 
 

Definition at line 1067 of file MRAsbBase.h.

Referenced by MRAsbObject.append(), copy(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), MRAsbObject.set_empty(), and MRAsbObject.store(). 

01067 { return _mspec; }

bool MRAsbBase::operator! (   ) 
 

Definition at line 657 of file MRAsbBase.h.

References is_null(). 

00657 { return is_null(); }

bool MRAsbBase::operator!= (  const MRAsbBase &   ) 
 

Definition at line 606 of file MRAsbBase.h.

References is_equal(). 

00606 { return !is_equal(rhs); }

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

Definition at line 300 of file MRAsbBase.h.

References _datatypecode, _mspec, _process_method, _process_sizeb, _sbn, _sbsizeb, and MRAmpEncode.grid_dim(). 

00303 {
00304    _state = goodbit;
00305    _mpenc = mpenc;
00306    _sbsizeb = 0;
00307    _sbn(_mpenc.grid_dim());
00308    _mspec(_mpenc.grid_dim());
00309    _datatypecode = 0;
00310    _process_sizeb = 3;
00311    _process_method = 0;
00312    if ( _ptbuffer != 0 ) delete _ptbuffer; 
00313    _ptbuffer = ptbuffer;
00314    return *this;
00315 }

MRAsbBase & MRAsbBase::operator() (  const MRAsbBase &  ,
BufferBase * 
) 
 

Definition at line 275 of file MRAsbBase.h.

References _cspec, _datatypecode, _mpenc, _mspec, _process, _process_method, _process_sizeb, _ptbuffer, _sbn, _sbsizeb, _state, BufferBase.get(), process_sizeb(), BufferBase.put(), BufferBase.seekg(), BufferBase.seekp(), and BufferBase.size(). 

00276 {
00277    _state = sb._state;
00278    _mpenc = sb._mpenc;
00279    _sbsizeb = sb._sbsizeb;
00280    _sbn = sb._sbn;
00281    _mspec = sb._mspec;
00282    _cspec = sb._cspec;
00283    _datatypecode = sb._datatypecode;
00284    _process_sizeb = sb._process_sizeb;
00285    _process_method = sb._process_method;
00286    if ( _ptbuffer != 0 ) delete _ptbuffer; 
00287    _ptbuffer = ptbuffer; 
00288    for( int i = 0; i < process_sizeb(); ++i ) _process[i] = sb._process[i];
00289    sb._ptbuffer->seekg(0);
00290    _ptbuffer->seekp(0);
00291    char c;
00292    for( int i = 0; i < sb._ptbuffer->size(); ++i ) {
00293       c = sb._ptbuffer->get();
00294       _ptbuffer->put( c );
00295    }
00296    return *this;
00297 }

MRAsbBase & MRAsbBase::operator() (  BufferBase *   ) 
 

Definition at line 266 of file MRAsbBase.h.

References set_null(). 

00267 { 
00268    if ( _ptbuffer != 0 ) delete _ptbuffer; 
00269    _ptbuffer = ptbuffer;
00270    set_null(); 
00271    return *this;
00272 }

MRAsbBase & MRAsbBase::operator<< (  BufferBase &   ) 
 

Definition at line 888 of file MRAsbBase.h.

References write(). 

00889 {
00890    write(buffer);
00891    return *this;
00892 }

MRAsbBase & MRAsbBase::operator= (  const MRAsbBase &   ) 
 

Definition at line 343 of file MRAsbBase.h.

References copy(). 

00343 { return copy(rhs); }

bool MRAsbBase::operator== (  const MRAsbBase &   ) 
 

Definition at line 603 of file MRAsbBase.h.

References is_equal(). 

00603 { return is_equal(rhs); }

MRAsbBase & MRAsbBase::operator>> (  BufferBase &   ) 
 

Definition at line 911 of file MRAsbBase.h.

References read(). 

00912 {
00913    read(buffer);
00914    return *this;
00915 }

char MRAsbBase::process (  int  i  ) 
 

Definition at line 1085 of file MRAsbBase.h.

References _process. 

01085 { return _process[i]; }

char * MRAsbBase::process (   ) 
 

Definition at line 1082 of file MRAsbBase.h.

References _process.

Referenced by copy(). 

01082 { return _process; }

int MRAsbBase::process_method (   ) 
 

Definition at line 1079 of file MRAsbBase.h.

References _process_method.

Referenced by copy(). 

01079 { return _process_method; }

int MRAsbBase::process_sizeb (   ) 
 

Definition at line 1076 of file MRAsbBase.h.

References _process_sizeb.

Referenced by copy(), fix_hdr(), is_equal(), MRAsbBase(), and operator()(). 

01076 { return _process_sizeb; }

int MRAsbBase::rdstate (  int  = 0xFF  ) 
 

Definition at line 618 of file MRAsbBase.h.

Referenced by baddim(), fail(), frag(), good(), hdrfixed(), and sbfixed(). 

00618 { return (_state & s); }

void MRAsbBase::read (  ostream &   ) 
 

Definition at line 940 of file MRAsbBase.h.

References _sbsizeb, BufferBase.get(), is_null(), and BufferBase.seekg(). 

00941 {
00942    if ( !is_null() ) {
00943       _ptbuffer->seekg(0);
00944       for( int i = 0; i < _sbsizeb; ++i ) {
00945          os.put( _ptbuffer->get() );
00946       }
00947    }
00948    else {
00949       bytepack bp;
00950       os << bp(0,4);
00951       os << bp(0,4);
00952    }
00953 }

void MRAsbBase::read (  BufferBase &   ) 
 

Definition at line 895 of file MRAsbBase.h.

References _sbsizeb, BufferBase.get(), is_null(), BufferBase.put(), and BufferBase.seekg().

Referenced by operator<<(), and operator>>(). 

00896 {
00897    if ( !is_null() ) {
00898       _ptbuffer->seekg(0);
00899       for( int i = 0; i < _sbsizeb; ++i ) {
00900          buffer.put( _ptbuffer->get() );
00901       }
00902    }
00903    else {
00904       bytepack bp;
00905       buffer << bp(0,4);
00906       buffer << bp(0,4);
00907    }
00908 }

void MRAsbBase::recover (  istream &   ) 
 

Definition at line 1006 of file MRAsbBase.h.

References _datatypecode, _mspec, _process, _process_method, _process_sizeb, _sbn, _sbsizeb, hdrsizeb(), BufferBase.put(), synchronize(), and BufferBase.write(). 

01006                                      { 
01007       bytepack bp;
01008       is >> _mpenc;
01009       *_ptbuffer << _mpenc;
01010 //      _mpenc.report();
01011 
01012       _sbn( _mpenc.grid_dim() );
01013       is >> _sbn; *_ptbuffer << _sbn;
01014 
01015       _mspec( _mpenc.grid_dim() );
01016       is >> _mspec; *_ptbuffer << _mspec;
01017 
01018       is >> _cspec; *_ptbuffer << _cspec;
01019 
01020       is >>  bp( 0, 1 ); _datatypecode = int(bp);
01021       _ptbuffer->write( bp( _datatypecode, 1 ) );
01022       is >>  bp( 0, 1 ); _process_sizeb = int(bp);
01023       _ptbuffer->write( bp( _process_sizeb, 1 ) );
01024       is >>  bp( 0, 1 ); _process_method = int(bp);
01025       _ptbuffer->write( bp( _process_method, 1 ) );
01026       for( int i = 0; i < _process_sizeb - 3; ++i ) {
01027          is.get( _process[i] );
01028          _ptbuffer->put( _process[i] );
01029       }
01030       is >>  bp( 0, 1 ); int tmp = int(bp);
01031       _ptbuffer->write( bp( tmp, 1 ) );
01032 
01033       _sbsizeb = hdrsizeb();
01034       int mpsizeb;
01035       do { 
01036          is >> bp( 0, _mpenc.bplen_mpsizeb() ); mpsizeb = int(bp);
01037          _ptbuffer->write( bp( mpsizeb, _mpenc.bplen_mpsizeb() ) );
01038          if ( mpsizeb != 0 ) {
01039             for( int i = 0; i < mpsizeb - _mpenc.bplen_mpsizeb(); ++i ) {
01040                _ptbuffer->put( is.get() );
01041             }
01042             _sbsizeb += mpsizeb;
01043          }
01044          else {
01045             is >> bp( 0, _mpenc.bplen_mpsizeb() );
01046             _ptbuffer->write( bp( 0, _mpenc.bplen_mpsizeb() ) );
01047             _sbsizeb += 2 * _mpenc.bplen_mpsizeb();
01048          }
01049       } while ( mpsizeb != 0 );
01050       is >> bp( 0, 4 );
01051       _sbsizeb += 4;
01052       _ptbuffer->write( bp( _sbsizeb, 4 ) );
01053       synchronize();
01054 }

void MRAsbBase::recover (  BufferBase &   ) 
 

Definition at line 956 of file MRAsbBase.h.

References _datatypecode, _mspec, _process, _process_method, _process_sizeb, _sbn, _sbsizeb, BufferBase.get(), hdrsizeb(), BufferBase.put(), synchronize(), and BufferBase.write().

Referenced by write(). 

00956                                             { 
00957       bytepack bp;
00958       buffer >> _mpenc;
00959       *_ptbuffer << _mpenc;
00960 //      _mpenc.report();
00961 
00962       _sbn( _mpenc.grid_dim() );
00963       buffer >> _sbn; *_ptbuffer << _sbn;
00964 
00965       _mspec( _mpenc.grid_dim() );
00966       buffer >> _mspec; *_ptbuffer << _mspec;
00967 
00968       buffer >> _cspec; *_ptbuffer << _cspec;
00969 
00970       buffer >>  bp( 0, 1 ); _datatypecode = int(bp);
00971       _ptbuffer->write( bp( _datatypecode, 1 ) );
00972       buffer >>  bp( 0, 1 ); _process_sizeb = int(bp);
00973       _ptbuffer->write( bp( _process_sizeb, 1 ) );
00974       buffer >>  bp( 0, 1 ); _process_method = int(bp);
00975       _ptbuffer->write( bp( _process_method, 1 ) );
00976       for( int i = 0; i < _process_sizeb - 3; ++i ) {
00977          buffer.get( _process[i] );
00978          _ptbuffer->put( _process[i] );
00979       }
00980       buffer >>  bp( 0, 1 ); int tmp = int(bp);
00981       _ptbuffer->write( bp( tmp, 1 ) );
00982 
00983       _sbsizeb = hdrsizeb();
00984       int mpsizeb;
00985       do { 
00986          buffer >> bp( 0, _mpenc.bplen_mpsizeb() ); mpsizeb = int(bp);
00987          _ptbuffer->write( bp( mpsizeb, _mpenc.bplen_mpsizeb() ) );
00988          if ( mpsizeb != 0 ) {
00989             for( int i = 0; i < mpsizeb - _mpenc.bplen_mpsizeb(); ++i ) {
00990                _ptbuffer->put( buffer.get() );
00991             }
00992             _sbsizeb += mpsizeb;
00993          }
00994          else {
00995             buffer >> bp( 0, _mpenc.bplen_mpsizeb() );
00996             _ptbuffer->write( bp( 0, _mpenc.bplen_mpsizeb() ) );
00997             _sbsizeb += 2 * _mpenc.bplen_mpsizeb();
00998          }
00999       } while ( mpsizeb != 0 );
01000       buffer >> bp( 0, 4 );
01001       _sbsizeb += 4;
01002       _ptbuffer->write( bp( _sbsizeb, 4 ) );
01003       synchronize();
01004 }

void MRAsbBase::refix_hdr (   ) 
 

Definition at line 726 of file MRAsbBase.h.

References _datatypecode, _sbsizeb, hdrfixed(), sbfixed(), BufferBase.seekp(), setstate(), BufferBase.tellp(), and BufferBase.write().

Referenced by set_cspec(), set_datatypecode(), set_mspec(), set_sbn(), and MRAsbObject.store(). 

00726                           { 
00727    if ( hdrfixed() ) {
00728       bytepack bp;
00729 //      setstate(hdrfixedbit);
00730 //      _sbsizeb = hdrsizeb();
00731       int save_putpos = _ptbuffer->tellp();
00732       _ptbuffer->seekp(0);
00733 
00734       if ( sbfixed() ) _ptbuffer->write( bp( _sbsizeb, 4 ) );
00735       else _ptbuffer->write( bp( 0, 4 ) );
00736 
00737       *_ptbuffer << _mpenc;
00738       *_ptbuffer << _sbn;
00739       *_ptbuffer << _mspec;
00740       *_ptbuffer << _cspec;
00741 
00742       _ptbuffer->write( bp( _datatypecode, 1 ) );
00743 
00744 // *** REWRITING process IS VERY DANGEROUS AND SHOULD NOT
00745 // *** BE DONE.  MORE REASON FOR CLASS REDESIGN
00746 //      _ptbuffer->write( bp( _process_sizeb, 1 ) );
00747 //      _ptbuffer->write( bp( _process_method, 1 ) );
00748 //      for( int i = 0; i < _process_sizeb - 3; ++i ) {
00749 //         _ptbuffer->put( _process[i] );
00750 //      }
00751 //      _ptbuffer->write( bp( process_sizeb(), 1 ) );
00752 
00753       _ptbuffer->seekp(save_putpos);
00754  
00755    }
00756    else { setstate(failbit); }
00757 }

bool MRAsbBase::sbfixed (   ) 
 

Definition at line 636 of file MRAsbBase.h.

References rdstate(), and sbfixedbit.

Referenced by append(), append_null(), begin(), end(), fix_sb(), refix_hdr(), and unfix_sb(). 

00636 { return rdstate(sbfixedbit) != 0; }

MRAsbn & MRAsbBase::sbn (   ) 
 

Definition at line 1064 of file MRAsbBase.h.

Referenced by copy(), and MRAsbObject.store(). 

01064 { return _sbn; }

int MRAsbBase::sbsizeb (   ) 
 

Definition at line 1061 of file MRAsbBase.h.

References _sbsizeb.

Referenced by MCFsb.mcfsizeb(), MCFTPmssg.mcftpsizeb(), MRAsbObject.sbsizeb(), MRAsbObject.sbsizeb_file(), and MRAsbObject.sbsizeb_mem(). 

01061 { return _sbsizeb; }

void MRAsbBase::set_cspec (  const MRAcrange &  cthis  ) 
 

Definition at line 853 of file MRAsbBase.h.

References MRAcspec.cthis, hdrfixed(), and refix_hdr(). 

00854 {
00855    _cspec.cthis = cthis;
00856    if ( hdrfixed() ) refix_hdr();
00857 }

void MRAsbBase::set_cspec (  const MRAcrange &  cthis,
const MRAcrange &  cexist,
const MRAcrange &  ctheory
) 
 

Definition at line 842 of file MRAsbBase.h.

References MRAcspec.cexist, MRAcspec.ctheory, MRAcspec.cthis, hdrfixed(), and refix_hdr(). 

00845 {
00846    _cspec.cthis = cthis;
00847    _cspec.cexist = cexist;
00848    _cspec.ctheory = ctheory;
00849    if ( hdrfixed() ) refix_hdr();
00850 }

void MRAsbBase::set_cspec (  const MRAcspec &   ) 
 

Definition at line 835 of file MRAsbBase.h.

References hdrfixed(), and refix_hdr(). 

00836 { 
00837    _cspec = cspec; 
00838    if ( hdrfixed() ) refix_hdr();
00839 }

void MRAsbBase::set_cspec (   ) 
 

Definition at line 821 of file MRAsbBase.h.

References MRAcspec.cexist, MRAcrange.cmax, MRAcrange.cmin, MRAcspec.ctheory, MRAcspec.cthis, hdrfixed(), and refix_hdr().

Referenced by append(), copy(), MRAsbObject.create_clone(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), and MRAsbObject.store(). 

00822 {
00823    _cspec.cthis.cmin = MRAclevel::cmin_limit;
00824    _cspec.cthis.cmax = MRAclevel::cmax_limit;
00825 
00826    _cspec.cexist.cmin = MRAclevel::cmin_limit;
00827    _cspec.cexist.cmax = MRAclevel::cmax_limit;
00828 
00829    _cspec.ctheory.cmin = MRAclevel::cmin_limit;
00830    _cspec.ctheory.cmax = MRAclevel::cmax_limit;
00831    if ( hdrfixed() ) refix_hdr();
00832 }

void MRAsbBase::set_datatypecode (  int  datatypecode  ) 
 

Definition at line 860 of file MRAsbBase.h.

References _datatypecode, hdrfixed(), and refix_hdr().

Referenced by copy(), MRAsbObject.create_clone(), and MRAsbObject.store(). 

00861 {
00862    _datatypecode = datatypecode;
00863    if ( hdrfixed() ) refix_hdr();
00864 }

MRAsbBase & MRAsbBase::set_empty (   ) 
 

Definition at line 660 of file MRAsbBase.h.

References clear(), BufferBase.erase(), fix_hdr(), and fix_sb().

Referenced by MRAsbObject.create_clone(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), and MRAsbObject.set_empty(). 

00661 { 
00662    clear();
00663    _ptbuffer->erase();
00664    fix_hdr();
00665    fix_sb();
00666    return *this;
00667 }

void MRAsbBase::set_mspec (  const MRAmrange &  mthis  ) 
 

Definition at line 814 of file MRAsbBase.h.

References hdrfixed(), MRAmspec.mthis, and refix_hdr(). 

00815 {
00816    _mspec.mthis = mthis;
00817    if ( hdrfixed() ) refix_hdr();
00818 }

void MRAsbBase::set_mspec (  const MRAmrange &  mthis,
const MRAmrange &  mexist,
const MRAmrange &  mtheory
) 
 

Definition at line 803 of file MRAsbBase.h.

References hdrfixed(), MRAmspec.mexist, MRAmspec.mtheory, MRAmspec.mthis, and refix_hdr(). 

00806 {
00807    _mspec.mthis = mthis;
00808    _mspec.mexist = mexist;
00809    _mspec.mtheory = mtheory;
00810    if ( hdrfixed() ) refix_hdr();
00811 }

void MRAsbBase::set_mspec (  const MRAmspec &   ) 
 

Definition at line 796 of file MRAsbBase.h.

References hdrfixed(), and refix_hdr(). 

00797 { 
00798    _mspec = mspec; 
00799    if ( hdrfixed() ) refix_hdr();
00800 }

void MRAsbBase::set_mspec (   ) 
 

Definition at line 781 of file MRAsbBase.h.

References hdrfixed(), MRAmspec.mexist, MRAmrange.mmax, MRAmrange.mmin, MRAmspec.mtheory, MRAmspec.mthis, and refix_hdr().

Referenced by append(), copy(), MRAsbObject.create_clone(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), and MRAsbObject.store(). 

00782 {
00783    _mspec.mthis.mmin = MRAmlevel::mmin_limit;
00784    _mspec.mthis.mmax = MRAmlevel::mmax_limit;
00785 
00786    _mspec.mexist.mmin = MRAmlevel::mmin_limit;
00787    _mspec.mexist.mmax = MRAmlevel::mmax_limit;
00788 
00789    _mspec.mtheory.mmin = MRAmlevel::mmin_limit;
00790    _mspec.mtheory.mmax = MRAmlevel::mmax_limit;
00791    
00792    if ( hdrfixed() ) refix_hdr();
00793 }

MRAsbBase & MRAsbBase::set_null (   ) 
 

Definition at line 639 of file MRAsbBase.h.

References _datatypecode, _mspec, _process_method, _process_sizeb, _sbn, _sbsizeb, BufferBase.erase(), and MRAmpEncode.set_null().

Referenced by MRAsbBase(), operator()(), and synchronize(). 

00640 { 
00641    _state = 0;
00642    _mpenc.set_null();
00643    _sbsizeb = 0;
00644    _sbn(0);
00645    _mspec(0);
00646    _datatypecode = 0;
00647    _process_sizeb = 3;
00648    _process_method = 0;
00649    _ptbuffer->erase();
00650    return *this;
00651 }

void MRAsbBase::set_sbn (  int  sbn  ) 
 

Definition at line 774 of file MRAsbBase.h.

References hdrfixed(), and refix_hdr(). 

00775 {
00776    _sbn = sbn;
00777    if ( hdrfixed() ) refix_hdr();
00778 }

void MRAsbBase::set_sbn (  const MRAsbn &   ) 
 

Definition at line 767 of file MRAsbBase.h.

References hdrfixed(), and refix_hdr(). 

00768 { 
00769    _sbn = sbn;
00770    if ( hdrfixed() ) refix_hdr();
00771 }

void MRAsbBase::set_sbn (   ) 
 

Definition at line 760 of file MRAsbBase.h.

References hdrfixed(), and refix_hdr().

Referenced by copy(), MRAsbObject.create_clone(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), MRAsbObject.store(), and MRAsbObject.synchronize(). 

00761 {
00762    _sbn = 0;
00763    if ( hdrfixed() ) refix_hdr();
00764 }

void MRAsbBase::setstate (  int   ) 
 

Definition at line 612 of file MRAsbBase.h.

Referenced by append(), append_null(), copy(), fix_hdr(), fix_sb(), refix_hdr(), unfix_sb(), and write(). 

00612 { _state |= s; }

void MRAsbBase::synchronize (   )  [private, virtual]
 

Definition at line 1463 of file MRAsbBase.h.

References _datatypecode, _mspec, _process, _process_method, _process_sizeb, _sbn, _sbsizeb, BufferBase.get(), BufferBase.read(), BufferBase.seekg(), BufferBase.seekp(), set_null(), BufferBase.size(), BufferBase.tellg(), and BufferBase.tellp().

Referenced by recover(), and write(). 

01464 {
01465    bytepack bp;
01466    int buffersizeb = _ptbuffer->size();
01467    _ptbuffer->seekg(0);
01468    _ptbuffer->read( bp(0,4) ); _sbsizeb = int(bp);
01469    if ( buffersizeb <= 8 ) { set_null(); }
01470    else {
01471       *_ptbuffer >> _mpenc;
01472 
01473       _sbn( _mpenc.grid_dim() );
01474       *_ptbuffer >> _sbn;
01475 
01476       _mspec( _mpenc.grid_dim() );
01477       *_ptbuffer >> _mspec;
01478 
01479       *_ptbuffer >> _cspec;
01480 
01481       _ptbuffer->read( bp(0,1) ); _datatypecode = int(bp);
01482       _ptbuffer->read( bp(0,1) ); _process_sizeb = int(bp);
01483       _ptbuffer->read( bp(0,1) ); _process_method = int(bp);
01484       for( int i = 0; i < _process_sizeb - 3; ++i ) 
01485          _process[i] = _ptbuffer->get();
01486       _ptbuffer->read( bp(0,1) );
01487       if ( _sbsizeb == -1 ) {
01488          int markp = _ptbuffer->tellp();
01489          int markg = _ptbuffer->tellg();
01490          _ptbuffer->seekg(-4,BufferBase::end);
01491          _ptbuffer->read( bp(0,4) ); _sbsizeb = int(bp);
01492          _ptbuffer->seekp(markp);
01493          _ptbuffer->seekg(markg);
01494       }
01495    }
01496 }

void MRAsbBase::unfix_sb (   ) 
 

Definition at line 711 of file MRAsbBase.h.

References _sbsizeb, clrstate(), hdrfixed(), MRAmpBase.nullsizeb(), sbfixed(), sbfixedbit, BufferBase.seekp(), setstate(), and BufferBase.write().

Referenced by append(), and MRAsbObject.store(). 

00712 {
00713    if ( hdrfixed() && sbfixed() ) {
00714       bytepack bp;
00715       _ptbuffer->seekp(0);
00716       _ptbuffer->write( bp( 0, 4 ) );
00717       MRAmp mp( _mpenc );
00718       _sbsizeb -= ( mp.nullsizeb() + 4 );
00719       _ptbuffer->seekp( _sbsizeb );
00720       clrstate(sbfixedbit);
00721    }
00722    else { setstate(failbit); }
00723 }

void MRAsbBase::write (  istream &   ) 
 

Definition at line 918 of file MRAsbBase.h.

References _sbsizeb, clear(), BufferBase.erase(), BufferBase.put(), recover(), sbfixedbit, setstate(), synchronize(), and BufferBase.write(). 

00919 {
00920    bytepack bp;
00921    _ptbuffer->erase();
00922    is >> bp(0,4); _sbsizeb = int(bp);
00923    _ptbuffer->write(bp);
00924    if ( _sbsizeb == 0 ) { _ptbuffer->write(bp); }
00925    else {
00926       if ( _sbsizeb != -1 ) {
00927          for( int i = 4; i < _sbsizeb; ++i ) _ptbuffer->put( is.get() );
00928       }
00929       else {
00930          recover(is);   
00931       }
00932    }
00933    clear();
00934    setstate(hdrfixedbit);
00935    setstate(sbfixedbit);
00936    synchronize();
00937 }

void MRAsbBase::write (  BufferBase &   ) 
 

Definition at line 867 of file MRAsbBase.h.

References _sbsizeb, clear(), BufferBase.erase(), BufferBase.get(), BufferBase.put(), recover(), sbfixedbit, setstate(), synchronize(), and BufferBase.write().

Referenced by operator<<(), and operator>>(). 

00868 {
00869    bytepack bp;
00870    _ptbuffer->erase();
00871    buffer >> bp(0,4); _sbsizeb = int(bp);
00872    _ptbuffer->write(bp);
00873    if ( _sbsizeb == 0 ) { 
00874       _ptbuffer->write(bp); 
00875    }
00876    else if ( _sbsizeb != -1 ) { 
00877       for( int i = 4; i < _sbsizeb; ++i ) _ptbuffer->put( buffer.get() );
00878    } else { 
00879       recover(buffer); 
00880    }
00881    clear();
00882    setstate(hdrfixedbit);
00883    setstate(sbfixedbit);
00884    synchronize();
00885 }

Friends And Related Function Documentation

friend class iterator [friend]
 

Definition at line 211 of file MRAsbBase.h.

friend class MRAsbObject [friend]
 

Definition at line 213 of file MRAsbBase.h.

ostream& operator<< (  ostream &  os,
MRAsbBase &  sb
)  [friend]
 

Definition at line 1607 of file MRAsbBase.h. 

01608 {
01609    sb.read(os);
01610    return os;
01611 }

BufferBase& operator<< (  BufferBase &  buffer,
MRAsbBase &  sb
)  [friend]
 

Definition at line 1593 of file MRAsbBase.h. 

01594 {
01595    sb.read(buffer);
01596    return buffer;
01597 }

istream& operator>> (  istream &  is,
MRAsbBase &  sb
)  [friend]
 

Definition at line 1614 of file MRAsbBase.h. 

01615 {
01616    sb.write(is);
01617    return is;
01618 }

BufferBase& operator>> (  BufferBase &  buffer,
MRAsbBase &  sb
)  [friend]
 

Definition at line 1600 of file MRAsbBase.h. 

01601 {
01602    sb.write(buffer);
01603    return buffer;
01604 }

Field Documentation

MRAcspec MRAsbBase._cspec [protected]
 

Definition at line 198 of file MRAsbBase.h.

Referenced by append(), copy(), is_equal(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), operator()(), and MRAsbObject.store().

int MRAsbBase._datatypecode [protected]
 

Definition at line 200 of file MRAsbBase.h.

Referenced by append(), copy(), datatypecode(), fix_hdr(), is_equal(), MRAsbObject.MRAsbObject(), operator()(), recover(), refix_hdr(), set_datatypecode(), set_null(), MRAsbObject.store(), and synchronize().

MRAmpEncode MRAsbBase._mpenc [protected]
 

Definition at line 192 of file MRAsbBase.h.

Referenced by append(), copy(), is_equal(), MRAsbBase.iterator.operator *(), MRAsbObject.operator()(), operator()(), and MRAsbBase.iterator.operator++().

MRAmspec MRAsbBase._mspec [protected]
 

Definition at line 197 of file MRAsbBase.h.

Referenced by append(), copy(), is_equal(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), operator()(), recover(), set_null(), MRAsbObject.store(), and synchronize().

char MRAsbBase._process[MRASBBASE_PROCESS_MAXSIZEB] [protected]
 

Definition at line 203 of file MRAsbBase.h.

Referenced by append(), copy(), fix_hdr(), is_equal(), MRAsbBase(), operator()(), process(), recover(), and synchronize().

int MRAsbBase._process_method [protected]
 

Definition at line 202 of file MRAsbBase.h.

Referenced by append(), copy(), fix_hdr(), is_equal(), operator()(), process_method(), recover(), set_null(), and synchronize().

int MRAsbBase._process_sizeb [protected]
 

Definition at line 201 of file MRAsbBase.h.

Referenced by append(), copy(), fix_hdr(), hdrsizeb(), is_equal(), operator()(), process_sizeb(), recover(), set_null(), and synchronize().

BufferBase* MRAsbBase._ptbuffer [protected]
 

Definition at line 205 of file MRAsbBase.h.

Referenced by copy(), is_equal(), MRAsbBase(), MRAsbBase.iterator.operator *(), operator()(), and MRAsbBase.iterator.operator++().

MRAsbn MRAsbBase._sbn [protected]
 

Definition at line 196 of file MRAsbBase.h.

Referenced by append(), copy(), is_equal(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), operator()(), recover(), set_null(), MRAsbObject.store(), and synchronize().

int MRAsbBase._sbsizeb [protected]
 

Definition at line 194 of file MRAsbBase.h.

Referenced by append(), append_null(), copy(), end(), fix_hdr(), fix_sb(), is_equal(), is_null(), operator()(), read(), recover(), refix_hdr(), sbsizeb(), set_null(), synchronize(), unfix_sb(), and write().

int MRAsbBase._state [protected]
 

Definition at line 190 of file MRAsbBase.h.

Referenced by copy(), is_equal(), and operator()().

const int MRAsbBase.baddimbit = 0x04 [static]
 

Definition at line 47 of file MRAsbBase.h.

const int MRAsbBase.failbit = 0x02 [static]
 

Definition at line 46 of file MRAsbBase.h.

const int MRAsbBase.fragbit = 0x08 [static]
 

Definition at line 48 of file MRAsbBase.h.

const int MRAsbBase.goodbit = 0x01 [static]
 

Definition at line 45 of file MRAsbBase.h.

const int MRAsbBase.hdrfixedbit = 0x10 [static]
 

Definition at line 49 of file MRAsbBase.h.

const int MRAsbBase.sbfixedbit = 0x20 [static]
 

Definition at line 50 of file MRAsbBase.h.

Referenced by fix_sb(), sbfixed(), unfix_sb(), and write().

The documentation for this class was generated from the following file:
Generated on Mon May 31 21:41:32 2004 for SR2k4 Assembler by doxygen 1.3.6