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

MRAsbObject Class Reference

#include <MRAsbObject.h>

Collaboration diagram for MRAsbObject:

Collaboration graph
[legend]

Public Types

typedef int Part
typedef int State
typedef int StateBit
typedef int Storage

Public Member Functions

MRAsbObject & append (MRAsbBase &)
void check_mpart ()
void clear ()
void clrstate (int)
MRAsbObject & copy (const MRAsbObject &rhs)
MRAclevel cpart ()
MRAsbBase * create_clone (MRAmrange, MRAcrange, Storage=MRAsbObject::file)
MRAsbBase * create_clone (MRAcrange, Storage=MRAsbObject::file)
MRAsbBase * create_clone (MRAmrange, Storage=MRAsbObject::file)
MRAsbBase * create_clone (Part, Storage)
MRAsbBase * create_clone (Storage=MRAsbObject::file)
MRAcspec cspec ()
CStatTable< int > cstattable_sbsizeb ()
bool fail ()
bool good ()
bool is_empty ()
bool is_equal (const MRAsbObject &)
bool is_null ()
MRAmlevel mpart ()
MRAmpEncode & mpenc ()
 MRAsbObject (MRAsbBase &)
 MRAsbObject (const MRAmpEncode &)
 MRAsbObject (const MRAsbObject &)
 MRAsbObject ()
MRAmspec mspec ()
MStatTable< int > mstattable_sbsizeb ()
bool operator! ()
bool operator!= (const MRAsbObject &)
MRAsbObject & operator() (MRAsbBase &)
MRAsbObject & operator() (const MRAmpEncode &)
MRAsbObject & operator() (const MRAsbObject &)
MRAsbObject & operator() ()
MRAsbObject & operator= (const MRAsbObject &rhs)
bool operator== (const MRAsbObject &)
int rdstate (int=0xFFFFFFFF)
void report ()
MRAsbn sbn ()
int sbsizeb (const Part p)
int sbsizeb ()
int sbsizeb_file ()
int sbsizeb_mem ()
void set_cpart (MRAclevel)
MRAsbObject & set_empty ()
void set_mpart (MRAmlevel)
MRAsbObject & set_null ()
void set_storage (Storage)
void set_storage (Part, Storage)
void setstate (int)
Storage storage (Part)
MRAsbObject & store (MRAsbBase &)
 ~MRAsbObject ()

Static Public Member Functions

string help_part (Part)
string help_storage (Storage)

Static Public Attributes

const int cfast = 0x02
const int cslow = 0x00
const int failbit = 0x02
const int file = 0x01
const int goodbit = 0x01
const int mem = 0x00
const int mfast = 0x01
const int mslow = 0x00
const int unspec = -1

Protected Attributes

MRAcrange _crange [MRASBOBJECT_PARTMAX]
MRAcspec _cspec
int _datatypecode
MRAmpEncode _mpenc
MRAmrange _mrange [MRASBOBJECT_PARTMAX]
MRAmspec _mspec
MRAsbBase * _ptsb [MRASBOBJECT_PARTMAX]
MRAsbn _sbn
int _state
Storage _storage [MRASBOBJECT_PARTMAX]

Private Member Functions

void synchronize ()

Friends

class MRAsbBase

Member Typedef Documentation

typedef int MRAsbObject.Part
 

Definition at line 62 of file MRAsbObject.h.

Referenced by append(), copy(), create_clone(), cstattable_sbsizeb(), help_part(), is_empty(), is_equal(), MRAsbObject(), mstattable_sbsizeb(), operator()(), sbsizeb(), sbsizeb_file(), sbsizeb_mem(), set_empty(), set_storage(), storage(), store(), synchronize(), and ~MRAsbObject().

typedef int MRAsbObject.State
 

Definition at line 60 of file MRAsbObject.h.

typedef int MRAsbObject.StateBit
 

Definition at line 61 of file MRAsbObject.h.

typedef int MRAsbObject.Storage
 

Definition at line 63 of file MRAsbObject.h.

Referenced by create_clone(), help_storage(), set_storage(), storage(), and synchronize().

Constructor & Destructor Documentation

MRAsbObject::MRAsbObject (   ) 
 

Definition at line 232 of file MRAsbObject.h.

References _crange, _mrange, _storage, cfast, cslow, file, MRAmpEncode.grid_dim(), mem, mfast, MRASBOBJECT_PARTMAX, mslow, Part, MRAcrange.set_empty(), MRAmrange.set_empty(), and MRAmpEncode.set_null(). 

00233   : _state(0)
00234 { 
00235    _mpenc.set_null();
00236 
00237    MRAmlevel mmin( _mpenc.grid_dim() );
00238    MRAmlevel mmax( _mpenc.grid_dim() );
00239    mmin = MRAmlevel::mmin_limit;
00240    mmax = MRAmlevel::mmax_limit;
00241 
00242    _mrange[mslow|cslow]( mmin, mmax );
00243 
00244    _mrange[mfast|cslow]( _mpenc.grid_dim() );
00245    _mrange[mfast|cslow].set_empty();
00246 
00247 #ifdef MRASBOBJECT_CPART_ALLOW
00248    _mrange[mslow|cfast]( _mpenc.grid_dim() );
00249    _mrange[mslow|cfast].set_empty();
00250 
00251    _mrange[mfast|cfast]( _mpenc.grid_dim() );
00252    _mrange[mfast|cfast].set_empty();
00253 #endif
00254 
00255    MRAclevel cmax;
00256    MRAclevel cmin;
00257    cmin = MRAclevel::cmin_limit;
00258    cmax = MRAclevel::cmax_limit;
00259 
00260    _crange[mslow|cslow]( cmin, cmax );
00261 
00262    _crange[mfast|cslow].set_empty();
00263 
00264 #ifdef MRASBOBJECT_CPART_ALLOW
00265    _crange[mslow|cfast].set_empty();
00266 
00267    _crange[mfast|cfast].set_empty();
00268 #endif
00269 
00270    _storage[mslow|cslow] = file;
00271    _storage[mfast|cslow] = file;
00272 #ifdef MRASBOBJECT_CPART_ALLOW
00273    _storage[mslow|cfast] = file;
00274    _storage[mfast|cfast] = mem;
00275 #endif
00276 
00277    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00278       if ( _storage[p] == mem ) _ptsb[p] = new MRAsb;
00279       else if ( _storage[p] == file ) _ptsb[p] = new MRAsbfstream;
00280       else _ptsb[p] = 0;
00281    }
00282 
00283 }

MRAsbObject.MRAsbObject (  const MRAsbObject &   ) 
 

MRAsbObject::MRAsbObject (  const MRAmpEncode &   )  [explicit]
 

Definition at line 286 of file MRAsbObject.h.

References _crange, _mrange, _storage, MRAcspec.cexist, cfast, cslow, MRAsbBase.cspec(), MRAcspec.ctheory, MRAcspec.cthis, file, MRAmpEncode.grid_dim(), mem, MRAmspec.mexist, mfast, MRASBOBJECT_PARTMAX, mslow, MRAsbBase.mspec(), MRAmspec.mtheory, MRAmspec.mthis, Part, MRAsbBase.set_cspec(), MRAsbBase.set_empty(), MRAcrange.set_empty(), MRAmrange.set_empty(), MRAsbBase.set_mspec(), and MRAsbBase.set_sbn(). 

00287   : _state(goodbit), _mpenc(mpenc), 
00288     _sbn( _mpenc.grid_dim() ), _mspec( _mpenc.grid_dim() )
00289 {
00290 
00291    _sbn = 0;
00292 
00293    MRAmlevel mmin( _mpenc.grid_dim() );
00294    MRAmlevel mmax( _mpenc.grid_dim() );
00295    mmin = MRAmlevel::mmin_limit;
00296    mmax = MRAmlevel::mmax_limit;
00297 
00298    _mspec.mthis.set_empty();
00299    _mspec.mexist(mmin,mmax);
00300    _mspec.mtheory(mmin,mmax);
00301 
00302    _mrange[mslow|cslow]( mmin, mmax );
00303 
00304    _mrange[mfast|cslow]( _mpenc.grid_dim() );
00305    _mrange[mfast|cslow].set_empty();
00306 
00307 #ifdef MRASBOBJECT_CPART_ALLOW
00308    _mrange[mslow|cfast]( _mpenc.grid_dim() );
00309    _mrange[mslow|cfast].set_empty();
00310 
00311    _mrange[mfast|cfast]( _mpenc.grid_dim() );
00312    _mrange[mfast|cfast].set_empty();
00313 #endif
00314 
00315    MRAclevel cmax;
00316    MRAclevel cmin;
00317    cmin = MRAclevel::cmin_limit;
00318    cmax = MRAclevel::cmax_limit;
00319 
00320    _cspec.cthis.set_empty();
00321    _cspec.cexist(cmin,cmax);
00322    _cspec.ctheory(cmin,cmax);
00323 
00324    _crange[mslow|cslow]( cmin, cmax );
00325 
00326    _crange[mfast|cslow].set_empty();
00327 
00328 #ifdef MRASBOBJECT_CPART_ALLOW
00329    _crange[mslow|cfast].set_empty();
00330 
00331    _crange[mfast|cfast].set_empty();
00332 #endif
00333 
00334    _storage[mslow|cslow] = file;
00335    _storage[mfast|cslow] = file;
00336 #ifdef MRASBOBJECT_CPART_ALLOW
00337    _storage[mslow|cfast] = file;
00338    _storage[mfast|cfast] = mem;
00339 #endif
00340 
00341    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00342       if ( _storage[p] == mem ) _ptsb[p] = new MRAsb(_mpenc);
00343       else if ( _storage[p] == file ) _ptsb[p] = new MRAsbfstream(_mpenc);
00344       else _ptsb[p] = 0;
00345       
00346       if ( _ptsb[p] != 0 ) {
00347          _ptsb[p]->set_sbn( _sbn );
00348          _ptsb[p]->set_mspec( _mspec );
00349          _ptsb[p]->mspec().mthis.set_empty();
00350          _ptsb[p]->set_cspec( _cspec );
00351          _ptsb[p]->cspec().cthis.set_empty();
00352          _ptsb[p]->set_empty();
00353       }
00354 
00355    }
00356 }

MRAsbObject::MRAsbObject (  MRAsbBase &   )  [explicit]
 

Definition at line 359 of file MRAsbObject.h.

References _crange, MRAsbBase._cspec, MRAsbBase._datatypecode, _mrange, MRAsbBase._mspec, MRAsbBase._sbn, _storage, cfast, cslow, MRAsbBase.cspec(), MRAcspec.cthis, file, MRAmpEncode.grid_dim(), mem, mfast, MRASBOBJECT_PARTMAX, mslow, MRAsbBase.mspec(), MRAmspec.mthis, Part, MRAsbBase.set_cspec(), MRAsbBase.set_empty(), MRAcrange.set_empty(), MRAmrange.set_empty(), MRAsbBase.set_mspec(), MRAsbBase.set_sbn(), and store(). 

00360   : _state(goodbit), _mpenc(sb._mpenc),
00361     _sbn( _mpenc.grid_dim() ), _mspec( _mpenc.grid_dim() )
00362 {
00363    _sbn = sb._sbn;
00364 
00365    MRAmlevel mmin( _mpenc.grid_dim() );
00366    MRAmlevel mmax( _mpenc.grid_dim() );
00367    mmin = MRAmlevel::mmin_limit;
00368    mmax = MRAmlevel::mmax_limit;
00369 
00370    _mspec = sb._mspec;
00371 
00372    _mrange[mslow|cslow]( mmin, mmax );
00373 
00374    _mrange[mfast|cslow]( _mpenc.grid_dim() );
00375    _mrange[mfast|cslow].set_empty();
00376 
00377 #ifdef MRASBOBJECT_CPART_ALLOW
00378    _mrange[mslow|cfast]( _mpenc.grid_dim() );
00379    _mrange[mslow|cfast].set_empty();
00380 
00381    _mrange[mfast|cfast]( _mpenc.grid_dim() );
00382    _mrange[mfast|cfast].set_empty();
00383 #endif
00384 
00385    MRAclevel cmax;
00386    MRAclevel cmin;
00387    cmin = MRAclevel::cmin_limit;
00388    cmax = MRAclevel::cmax_limit;
00389 
00390    _cspec = sb._cspec;
00391 
00392    _crange[mslow|cslow]( cmin, cmax );
00393 
00394    _crange[mfast|cslow].set_empty();
00395 
00396 #ifdef MRASBOBJECT_CPART_ALLOW
00397    _crange[mslow|cfast].set_empty();
00398 
00399    _crange[mfast|cfast].set_empty();
00400 #endif
00401 
00402    _storage[mslow|cslow] = file;
00403    _storage[mfast|cslow] = file;
00404 #ifdef MRASBOBJECT_CPART_ALLOW
00405    _storage[mslow|cfast] = file;
00406    _storage[mfast|cfast] = mem;
00407 #endif
00408 
00409    _datatypecode = sb._datatypecode;
00410 
00411    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00412       if ( _storage[p] == mem ) _ptsb[p] = new MRAsb(_mpenc);
00413       else if ( _storage[p] == file ) _ptsb[p] = new MRAsbfstream(_mpenc);
00414       else _ptsb[p] = 0;
00415 
00416       if ( _ptsb[p] != 0 ) {
00417          _ptsb[p]->set_sbn( _sbn );
00418          _ptsb[p]->set_mspec( _mspec );
00419          _ptsb[p]->mspec().mthis.set_empty();
00420          _ptsb[p]->set_cspec( _cspec );
00421          _ptsb[p]->cspec().cthis.set_empty();
00422          _ptsb[p]->set_empty();
00423       }
00424    }
00425 
00426    store(sb);
00427 }

MRAsbObject::~MRAsbObject (   ) 
 

Definition at line 431 of file MRAsbObject.h.

References MRASBOBJECT_PARTMAX, and Part. 

00432 {
00433    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p )
00434       if ( _ptsb[p] != 0 ) { delete _ptsb[p]; _ptsb[p] = 0; }
00435 }

Member Function Documentation

MRAsbObject & MRAsbObject::append (  MRAsbBase &   ) 
 

Definition at line 841 of file MRAsbObject.h.

References _crange, _mrange, MRAsbBase.append(), MRAsbBase.cspec(), MRAcspec.cthis, MRASBOBJECT_PARTMAX, MRAsbBase.mspec(), MRAmspec.mthis, and Part. 

00842 {
00843    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00844       _ptsb[p]->mspec().mthis = sb.mspec().mthis * _mrange[p];
00845       _ptsb[p]->cspec().cthis = sb.cspec().cthis * _crange[p];
00846       _ptsb[p]->append( sb, _mrange[p] );
00847    }
00848 }

void MRAsbObject.check_mpart (   ) 
 

Definition at line 40 of file MRAsbObject.h.

References _mrange, mpart(), MRAmrange.report(), and MRAmlevel.report(). 

00040                          {
00041          cout << "check_mpart\n";
00042          mpart().report();
00043          _mrange[0].report();
00044          _mrange[1].report();
00045       }

void MRAsbObject::clear (   ) 
 

Definition at line 696 of file MRAsbObject.h.

Referenced by store(). 

00696 { _state = goodbit; }

void MRAsbObject::clrstate (  int   ) 
 

Definition at line 702 of file MRAsbObject.h. 

00702 { _state &= ~s; }

MRAsbObject & MRAsbObject::copy (  const MRAsbObject &  rhs  ) 
 

Definition at line 599 of file MRAsbObject.h.

References _crange, _cspec, _mpenc, _mrange, _mspec, _ptsb, _sbn, _state, _storage, file, mem, MRASBOBJECT_PARTMAX, Part, and set_null().

Referenced by operator=(). 

00600 {
00601    if ( _state == 0 ) set_null();
00602    else {
00603       _state = sbo._state;
00604       _mpenc = sbo._mpenc;
00605       _sbn = sbo._sbn;
00606       _mspec = sbo._mspec;
00607       _cspec = sbo._cspec;
00608       for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00609          _mrange[p] = sbo._mrange[p];
00610          _crange[p] = sbo._crange[p];
00611          _storage[p] = sbo._storage[p];
00612          if ( _ptsb[p] != 0 ) { delete _ptsb[p]; }
00613 
00614          if ( _storage[p] == mem ) _ptsb[p] = new MRAsb( _mpenc );
00615          else if ( _storage[p] == file ) _ptsb[p] = new MRAsbfstream( _mpenc );
00616          else _ptsb[p] = 0;
00617 
00618          if ( _ptsb[p] != 0 ) *_ptsb[p] = *sbo._ptsb[p];
00619       }
00620    }
00621    return *this;
00622 }

MRAclevel MRAsbObject::cpart (   ) 
 

Definition at line 782 of file MRAsbObject.h.

References _crange, MRAcrange.cmax, cpart(), cslow, and mslow.

Referenced by cpart(). 

00783 { 
00784    MRAclevel cpart;
00785    cpart = _crange[mslow|cslow].cmax;
00786    return cpart;
00787 }

MRAsbBase * MRAsbObject::create_clone (  MRAmrange  ,
MRAcrange  ,
Storage  = MRAsbObject::file
) 
 

Definition at line 958 of file MRAsbObject.h.

References MRAsbBase.append(), MRAcspec.cthis, file, mem, MRASBOBJECT_PARTMAX, MRAmspec.mthis, Part, MRAsbBase.set_cspec(), MRAsbBase.set_datatypecode(), MRAsbBase.set_empty(), MRAsbBase.set_mspec(), MRAsbBase.set_sbn(), setstate(), and Storage. 

00961 {
00962    MRAsbBase* ptsb;
00963 
00964    if ( storage == mem ) { 
00965       ptsb = new MRAsb( _mpenc );
00966    } else if ( storage == file )  {
00967       ptsb = new MRAsbfstream( _mpenc );
00968    } else { 
00969       ptsb = 0; 
00970       setstate(failbit);
00971       return ptsb;
00972    }
00973 
00974    ptsb->set_sbn( _sbn );
00975    ptsb->set_mspec( _mspec );
00976    ptsb->set_mspec( _mspec.mthis * mrange );
00977    ptsb->set_cspec( _cspec );
00978    ptsb->set_cspec( _cspec.cthis * crange );
00979    ptsb->set_datatypecode( _datatypecode );
00980 
00981    ptsb->set_empty();
00982 
00983    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00984       ptsb->append( *_ptsb[p], mrange, crange );
00985    }
00986 
00987    return ptsb;
00988 }

MRAsbBase * MRAsbObject::create_clone (  MRAcrange  ,
Storage  = MRAsbObject::file
) 
 

Definition at line 928 of file MRAsbObject.h.

References MRAsbBase.append(), MRAcspec.cthis, file, mem, MRASBOBJECT_PARTMAX, Part, MRAsbBase.set_cspec(), MRAsbBase.set_datatypecode(), MRAsbBase.set_empty(), MRAsbBase.set_mspec(), MRAsbBase.set_sbn(), setstate(), and Storage. 

00929 {
00930    MRAsbBase* ptsb;
00931 
00932    if ( storage == mem ) { 
00933       ptsb = new MRAsb( _mpenc );
00934    } else if ( storage == file )  {
00935       ptsb = new MRAsbfstream( _mpenc );
00936    } else { 
00937       ptsb = 0; 
00938       setstate(failbit);
00939       return ptsb;
00940    }
00941 
00942    ptsb->set_sbn( _sbn );
00943    ptsb->set_mspec( _mspec );
00944    ptsb->set_cspec( _cspec );
00945    ptsb->set_cspec( _cspec.cthis * crange );
00946    ptsb->set_datatypecode( _datatypecode );
00947 
00948    ptsb->set_empty();
00949 
00950    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00951       ptsb->append( *_ptsb[p], crange );
00952    }
00953 
00954    return ptsb;
00955 }

MRAsbBase * MRAsbObject::create_clone (  MRAmrange  ,
Storage  = MRAsbObject::file
) 
 

Definition at line 898 of file MRAsbObject.h.

References MRAsbBase.append(), file, mem, MRASBOBJECT_PARTMAX, MRAmspec.mthis, Part, MRAsbBase.set_cspec(), MRAsbBase.set_datatypecode(), MRAsbBase.set_empty(), MRAsbBase.set_mspec(), MRAsbBase.set_sbn(), setstate(), and Storage. 

00899 {
00900    MRAsbBase* ptsb;
00901 
00902    if ( storage == mem ) { 
00903       ptsb = new MRAsb( _mpenc );
00904    } else if ( storage == file )  {
00905       ptsb = new MRAsbfstream( _mpenc );
00906    } else { 
00907       ptsb = 0; 
00908       setstate(failbit);
00909       return ptsb;
00910    }
00911 
00912    ptsb->set_sbn( _sbn );
00913    ptsb->set_mspec( _mspec );
00914    ptsb->set_mspec( _mspec.mthis * mrange );
00915    ptsb->set_cspec( _cspec );
00916    ptsb->set_datatypecode( _datatypecode );
00917 
00918    ptsb->set_empty();
00919 
00920    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00921       ptsb->append( *_ptsb[p], mrange );
00922    }
00923 
00924    return ptsb;
00925 }

MRAsbBase * MRAsbObject::create_clone (  Part  ,
Storage 
) 
 

Definition at line 879 of file MRAsbObject.h.

References MRAsbBase.copy(), file, mem, Part, setstate(), and Storage. 

00880 {
00881    MRAsbBase* ptsb;
00882    if ( storage == mem ) { 
00883       ptsb = new MRAsb( _mpenc );
00884    } else if ( storage == file )  {
00885       ptsb = new MRAsbfstream( _mpenc );
00886    } else { 
00887       ptsb = 0; 
00888       setstate(failbit);
00889       return ptsb;
00890    }
00891 
00892    (*ptsb).copy( *_ptsb[p] );
00893 
00894    return ptsb;
00895 }

MRAsbBase * MRAsbObject::create_clone (  Storage  = MRAsbObject::file  ) 
 

Definition at line 851 of file MRAsbObject.h.

References MRAsbBase.append(), file, mem, MRASBOBJECT_PARTMAX, Part, MRAsbBase.set_cspec(), MRAsbBase.set_datatypecode(), MRAsbBase.set_empty(), MRAsbBase.set_mspec(), MRAsbBase.set_sbn(), setstate(), and Storage.

Referenced by synchronize(). 

00852 {
00853 
00854    MRAsbBase* ptsb;
00855 
00856    if ( storage == mem ) { 
00857       ptsb = new MRAsb( _mpenc );
00858    } else if ( storage == file )  {
00859       ptsb = new MRAsbfstream( _mpenc );
00860    } else { 
00861       ptsb = 0; 
00862       setstate(failbit);
00863       return ptsb;
00864    }
00865 
00866    ptsb->set_sbn( _sbn );
00867    ptsb->set_mspec( _mspec );
00868    ptsb->set_cspec( _cspec );
00869    ptsb->set_datatypecode( _datatypecode );
00870 
00871    ptsb->set_empty();
00872 
00873    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) ptsb->append( *_ptsb[p] );
00874 
00875    return ptsb;
00876 }

MRAcspec MRAsbObject::cspec (   ) 
 

Definition at line 720 of file MRAsbObject.h. 

00720 { return _cspec; }

MRAsbObject::CStatTable< int > MRAsbObject::cstattable_sbsizeb (   ) 
 

Definition at line 1130 of file MRAsbObject.h.

References MRAmpBase.acoefsizeb(), MRAmpBase.begin(), MRAsbBase.begin(), MRAacoef.bpcoef, MRAmpEncode.bplen_mpsizeb(), castc_double(), castc_float(), DataTypeCode_type< Type >.code(), MRAmpBase.end(), MRAmpBase.hdrsizeb(), MRAmpBase.mpenc(), MRASBOBJECT_PARTMAX, and Part. 

01131 {
01132 //this should becom part of class
01133    int (*castc)( bytepack );
01134    if ( _datatypecode == DataTypeCode_type<float>::code() ) {
01135       castc = castc_float;
01136    } else if ( _datatypecode == DataTypeCode_type<double>::code() ) {
01137       castc = castc_double;
01138    } else {
01139       castc = 0;
01140    }
01141 
01142    CStatTable<int> cstattable;
01143 
01144    MRAmp mp;
01145 
01146    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
01147       for( 
01148         MRAsbBase::iterator iter = _ptsb[p]->begin(); 
01149         iter < _ptsb[p]->end(); 
01150         ++iter 
01151       ) { 
01152          mp = *iter;
01153 
01154          MRAacoef acoef;
01155          MRAclevel clevel;
01156 
01157          CStatTable<int> tmpsum;
01158 
01159          for( MRAmpBase::iterator itmp=mp.begin(); itmp < mp.end(); ++itmp ) {
01160             acoef = *itmp;
01161             clevel = castc(acoef.bpcoef);
01162             tmpsum[int(clevel)] += mp.acoefsizeb();
01163          }
01164 
01165          for(int c = MRAclevel::cmin_limit; c <= MRAclevel::cmax_limit; ++c) {
01166             if ( tmpsum[c] != 0 ) cstattable[c] += tmpsum[c];
01167               + mp.hdrsizeb() + mp.mpenc().bplen_mpsizeb();
01168          }
01169 
01170       }
01171    }
01172 
01173    return cstattable;
01174 
01175 }

bool MRAsbObject::fail (   ) 
 

Definition at line 711 of file MRAsbObject.h.

References rdstate(). 

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

bool MRAsbObject::good (   ) 
 

Definition at line 708 of file MRAsbObject.h. 

00708 { return _state == goodbit; }

string MRAsbObject::help_part (  Part   )  [static]
 

Definition at line 187 of file MRAsbObject.h.

References cfast, cslow, mfast, mslow, and Part. 

00188 {
00189 #if MRASBOBJECT_CPART_ALLOW
00190    switch(part) {
00191       case mslow|cslow:
00192          return " ==> MRAsbObject::mslow | MRAsbObject::cslow ";
00193          break;
00194       case mfast|cslow:
00195          return " ==> MRAsbObject::mfast | MRAsbObject::cslow ";
00196          break;
00197       case mslow|cfast:
00198          return " ==> MRAsbObject::mslow | MRAsbObject::cfast ";
00199          break;
00200       case mfast|cfast:
00201          return " ==> MRAsbObject::mfast | MRAsbObject::cfast ";
00202          break;
00203    }
00204 #else
00205    switch(part) {
00206       case mslow:
00207          return " ==> MRAsbObject::mslow ";
00208          break;
00209       case mfast:
00210          return " ==> MRAsbObject::mfast ";
00211          break;
00212    }
00213 #endif
00214    return "";
00215 }

string MRAsbObject::help_storage (  Storage   )  [static]
 

Definition at line 218 of file MRAsbObject.h.

References file, mem, and Storage. 

00219 {
00220    switch(storage) {
00221       case mem:
00222          return " ==> MRAsbObject::mem ";
00223          break;
00224       case file:
00225          return " ==> MRAsbObject::file ";
00226          break;
00227    }
00228    return "";
00229 }

bool MRAsbObject::is_empty (   ) 
 

Definition at line 684 of file MRAsbObject.h.

References MRAsbBase.is_empty(), MRASBOBJECT_PARTMAX, and Part. 

00685 { 
00686    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00687       if ( _ptsb[p] != 0 && !(_ptsb[p]->is_empty()) ) return false;
00688    }
00689    return true;
00690 }

bool MRAsbObject::is_equal (  const MRAsbObject &   ) 
 

Definition at line 631 of file MRAsbObject.h.

References _crange, _cspec, _mpenc, _mrange, _mspec, _ptsb, _sbn, _state, _storage, is_null(), MRASBOBJECT_PARTMAX, and Part.

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

00632 {
00633    if ( _state != sbo._state ) return false;
00634    if ( _mpenc != sbo._mpenc ) return false;
00635    if ( _sbn != sbo._sbn ) return false;
00636    if ( _mspec != sbo._mspec ) return false;
00637    if ( _cspec != sbo._cspec ) return false;
00638    if ( is_null() || _state == 0 ) return true;
00639    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00640       if ( _mrange[p] != sbo._mrange[p] ) return false;
00641       if ( _crange[p] != sbo._crange[p] ) return false;
00642       if ( _storage[p] != sbo._storage[p] ) return false;
00643       if ( *_ptsb[p] != *sbo._ptsb[p] ) return false;
00644    }
00645    return true;
00646 }

bool MRAsbObject::is_null (   ) 
 

Definition at line 668 of file MRAsbObject.h.

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

00668 { return ( _state == 0 ); }

MRAmlevel MRAsbObject::mpart (   ) 
 

Definition at line 751 of file MRAsbObject.h.

References _mrange, cslow, MRAmpEncode.grid_dim(), MRAmrange.mmax, and mslow.

Referenced by check_mpart(). 

00752 { 
00753    MRAmlevel mpart( _mpenc.grid_dim() );
00754    mpart = _mrange[mslow|cslow].mmax;
00755    return mpart;
00756 }

MRAmpEncode & MRAsbObject::mpenc (   ) 
 

Definition at line 811 of file MRAsbObject.h. 

00811 { return _mpenc; }

MRAmspec MRAsbObject::mspec (   ) 
 

Definition at line 717 of file MRAsbObject.h. 

00717 { return _mspec; }

MRAsbObject::MStatTable< int > MRAsbObject::mstattable_sbsizeb (   ) 
 

Definition at line 1085 of file MRAsbObject.h.

References MRAsbBase.begin(), MRAmpEncode.grid_dim(), MRAmpBase.mcode_to_m(), MRAmpBase.mpsizeb(), MRASBOBJECT_PARTMAX, and Part. 

01086 {
01087    MStatTable<int> mstattable;
01088 
01089    int mtmp;
01090    MRAmp mp;
01091 
01092    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
01093       for( 
01094         MRAsbBase::iterator iter = _ptsb[p]->begin(); 
01095         iter < _ptsb[p]->end(); 
01096         ++iter 
01097       ) { 
01098          mp = *iter;
01099          mtmp=mp.mcode_to_m(0);
01100          for( int d = 1; d < _mpenc.grid_dim(); ++d ) {
01101             mtmp = min( mtmp, mp.mcode_to_m(d) );
01102          }
01103          mstattable[mtmp] += mp.mpsizeb();
01104       }
01105    }
01106 
01107    return mstattable;
01108 }

bool MRAsbObject::operator! (   ) 
 

Definition at line 693 of file MRAsbObject.h.

References is_null(). 

00693 { return is_null(); }

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

Definition at line 655 of file MRAsbObject.h.

References is_equal(). 

00656 {
00657    return !is_equal(rhs); 
00658 }

MRAsbObject & MRAsbObject::operator() (  MRAsbBase &   ) 
 

Definition at line 523 of file MRAsbObject.h.

References _crange, MRAsbBase._cspec, MRAsbBase._mpenc, _mrange, MRAsbBase._mspec, _mspec, MRAsbBase._sbn, _sbn, _storage, cfast, cslow, MRAsbBase.cspec(), MRAcspec.cthis, file, MRAmpEncode.grid_dim(), mem, mfast, MRASBOBJECT_PARTMAX, mslow, MRAsbBase.mspec(), MRAmspec.mthis, Part, MRAsbBase.set_cspec(), MRAsbBase.set_empty(), MRAcrange.set_empty(), MRAmrange.set_empty(), MRAsbBase.set_mspec(), MRAsbBase.set_sbn(), and store(). 

00524 {
00525    _state = goodbit;
00526    _mpenc = sb._mpenc;
00527 
00528    _sbn( _mpenc.grid_dim() );
00529    _mspec( _mpenc.grid_dim() );
00530 
00531    _sbn = sb._sbn;
00532 
00533    MRAmlevel mmin( _mpenc.grid_dim() );
00534    MRAmlevel mmax( _mpenc.grid_dim() );
00535    mmin = MRAmlevel::mmin_limit;
00536    mmax = MRAmlevel::mmax_limit;
00537 
00538    _mspec = sb._mspec;
00539 
00540    _mrange[mslow|cslow]( mmin, mmax );
00541 
00542    _mrange[mfast|cslow]( _mpenc.grid_dim() );
00543    _mrange[mfast|cslow].set_empty();
00544 
00545 #ifdef MRASBOBJECT_CPART_ALLOW
00546    _mrange[mslow|cfast]( _mpenc.grid_dim() );
00547    _mrange[mslow|cfast].set_empty();
00548 
00549    _mrange[mfast|cfast]( _mpenc.grid_dim() );
00550    _mrange[mfast|cfast].set_empty();
00551 #endif
00552 
00553    MRAclevel cmax;
00554    MRAclevel cmin;
00555    cmin = MRAclevel::cmin_limit;
00556    cmax = MRAclevel::cmax_limit;
00557 
00558    _cspec = sb._cspec;
00559 
00560    _crange[mslow|cslow]( cmin, cmax );
00561 
00562    _crange[mfast|cslow].set_empty();
00563 
00564 #ifdef MRASBOBJECT_CPART_ALLOW
00565    _crange[mslow|cfast].set_empty();
00566 
00567    _crange[mfast|cfast].set_empty();
00568 #endif
00569 
00570    _storage[mslow|cslow] = file;
00571    _storage[mfast|cslow] = file;
00572 #ifdef MRASBOBJECT_CPART_ALLOW
00573    _storage[mslow|cfast] = file;
00574    _storage[mfast|cfast] = mem;
00575 #endif
00576 
00577    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00578       if ( _ptsb[p] != 0 ) { delete _ptsb[p]; _ptsb[p] = 0; }
00579       if ( _storage[p] == mem ) _ptsb[p] = new MRAsb(_mpenc);
00580       else if ( _storage[p] == file ) _ptsb[p] = new MRAsbfstream(_mpenc);
00581       else _ptsb[p] = 0;
00582 
00583       if ( _ptsb[p] != 0 ) {
00584          _ptsb[p]->set_sbn( _sbn );
00585          _ptsb[p]->set_mspec( _mspec );
00586          _ptsb[p]->mspec().mthis.set_empty();
00587          _ptsb[p]->set_cspec( _cspec );
00588          _ptsb[p]->cspec().cthis.set_empty();
00589          _ptsb[p]->set_empty();
00590       }
00591    }
00592 
00593    store(sb);
00594 
00595    return *this;
00596 }

MRAsbObject & MRAsbObject::operator() (  const MRAmpEncode &   ) 
 

Definition at line 444 of file MRAsbObject.h.

References _crange, _mrange, _mspec, _sbn, _storage, MRAcspec.cexist, cfast, cslow, MRAsbBase.cspec(), MRAcspec.ctheory, MRAcspec.cthis, file, MRAmpEncode.grid_dim(), mem, MRAmspec.mexist, mfast, MRASBOBJECT_PARTMAX, mslow, MRAsbBase.mspec(), MRAmspec.mtheory, MRAmspec.mthis, Part, MRAsbBase.set_cspec(), MRAsbBase.set_empty(), MRAcrange.set_empty(), MRAmrange.set_empty(), MRAsbBase.set_mspec(), and MRAsbBase.set_sbn(). 

00445 {
00446    _state = goodbit;
00447    _mpenc = mpenc;
00448 
00449    _sbn( _mpenc.grid_dim() );
00450    _mspec( _mpenc.grid_dim() );
00451 
00452    _sbn = 0;
00453 
00454    MRAmlevel mmin( _mpenc.grid_dim() );
00455    MRAmlevel mmax( _mpenc.grid_dim() );
00456    mmin = MRAmlevel::mmin_limit;
00457    mmax = MRAmlevel::mmax_limit;
00458 
00459    _mspec.mthis.set_empty();
00460    _mspec.mexist(mmin,mmax);
00461    _mspec.mtheory(mmin,mmax);
00462 
00463    _mrange[mslow|cslow]( mmin, mmax );
00464 
00465    _mrange[mfast|cslow]( _mpenc.grid_dim() );
00466    _mrange[mfast|cslow].set_empty();
00467 
00468 #ifdef MRASBOBJECT_CPART_ALLOW
00469    _mrange[mslow|cfast]( _mpenc.grid_dim() );
00470    _mrange[mslow|cfast].set_empty();
00471 
00472    _mrange[mfast|cfast]( _mpenc.grid_dim() );
00473    _mrange[mfast|cfast].set_empty();
00474 #endif
00475 
00476    MRAclevel cmax;
00477    MRAclevel cmin;
00478    cmin = MRAclevel::cmin_limit;
00479    cmax = MRAclevel::cmax_limit;
00480 
00481    _cspec.cthis.set_empty();
00482    _cspec.cexist(cmin,cmax);
00483    _cspec.ctheory(cmin,cmax);
00484 
00485    _crange[mslow|cslow]( cmin, cmax );
00486 
00487    _crange[mfast|cslow].set_empty();
00488 
00489 #ifdef MRASBOBJECT_CPART_ALLOW
00490    _crange[mslow|cfast].set_empty();
00491 
00492    _crange[mfast|cfast].set_empty();
00493 #endif
00494 
00495    _storage[mslow|cslow] = file;
00496    _storage[mfast|cslow] = file;
00497 #ifdef MRASBOBJECT_CPART_ALLOW
00498    _storage[mslow|cfast] = file;
00499    _storage[mfast|cfast] = mem;
00500 #endif
00501 
00502    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00503       if ( _ptsb[p] != 0 ) { delete _ptsb[p]; _ptsb[p] = 0; }
00504       if ( _storage[p] == mem ) _ptsb[p] = new MRAsb(_mpenc);
00505       else if ( _storage[p] == file ) _ptsb[p] = new MRAsbfstream(_mpenc);
00506       else _ptsb[p] = 0;
00507 
00508       if ( _ptsb[p] != 0 ) {
00509          _ptsb[p]->set_sbn( _sbn );
00510          _ptsb[p]->set_mspec( _mspec );
00511          _ptsb[p]->mspec().mthis.set_empty();
00512          _ptsb[p]->set_cspec( _cspec );
00513          _ptsb[p]->cspec().cthis.set_empty();
00514          _ptsb[p]->set_empty();
00515       }
00516    }
00517 
00518    return *this;
00519 }

MRAsbObject& MRAsbObject.operator() (  const MRAsbObject &   ) 
 

MRAsbObject & MRAsbObject::operator() (   ) 
 

Definition at line 438 of file MRAsbObject.h.

References set_null(). 

00439 {  
00440    set_null();
00441 }

MRAsbObject & MRAsbObject::operator= (  const MRAsbObject &  rhs  ) 
 

Definition at line 625 of file MRAsbObject.h.

References copy(). 

00626 { 
00627    return copy(rhs); 
00628 }

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

Definition at line 649 of file MRAsbObject.h.

References is_equal(). 

00650 { 
00651    return is_equal(rhs); 
00652 }

int MRAsbObject::rdstate (  int  = 0xFFFFFFFF  ) 
 

Definition at line 705 of file MRAsbObject.h.

Referenced by fail(). 

00705 { return (_state & s); }

void MRAsbObject.report (   ) 
 

MRAsbn MRAsbObject::sbn (   ) 
 

Definition at line 714 of file MRAsbObject.h. 

00714 { return _sbn; }

int MRAsbObject::sbsizeb (  const Part  p  ) 
 

Definition at line 999 of file MRAsbObject.h.

References MRASBOBJECT_PARTMAX, Part, and MRAsbBase.sbsizeb(). 

01000 {
01001    if(  p >= 0 && p < MRASBOBJECT_PARTMAX ) return _ptsb[p]->sbsizeb();
01002    else return 0;
01003 }

int MRAsbObject::sbsizeb (   ) 
 

Definition at line 991 of file MRAsbObject.h.

References MRASBOBJECT_PARTMAX, Part, and MRAsbBase.sbsizeb(). 

00992 {
00993    int tmp = 0;
00994    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) tmp += _ptsb[p]->sbsizeb();
00995    return tmp;
00996 }

int MRAsbObject::sbsizeb_file (   ) 
 

Definition at line 1016 of file MRAsbObject.h.

References _storage, file, MRASBOBJECT_PARTMAX, Part, and MRAsbBase.sbsizeb(). 

01017 {
01018    int tmp = 0;
01019    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
01020       if ( _storage[p] == MRAsbObject::file ) tmp += _ptsb[p]->sbsizeb();
01021    }
01022    return tmp;
01023 }

int MRAsbObject::sbsizeb_mem (   ) 
 

Definition at line 1006 of file MRAsbObject.h.

References _storage, mem, MRASBOBJECT_PARTMAX, Part, and MRAsbBase.sbsizeb(). 

01007 {
01008    int tmp = 0;
01009    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
01010       if ( _storage[p] == MRAsbObject::mem ) tmp += _ptsb[p]->sbsizeb();
01011    }
01012    return tmp;
01013 }

void MRAsbObject::set_cpart (  MRAclevel   ) 
 

Definition at line 759 of file MRAsbObject.h.

References _crange, cfast, cslow, MRAcspec.cthis, mfast, mslow, and synchronize(). 

00760 { 
00761 
00762       MRAclevel cmin_limit;
00763       MRAclevel cmax_limit;
00764 
00765       cmin_limit = MRAclevel::cmin_limit;
00766       cmax_limit = MRAclevel::cmax_limit;;
00767 
00768       MRAcrange crange;
00769 
00770       _crange[mslow|cslow] = _cspec.cthis * crange( cmin_limit, cpart );
00771       _crange[mfast|cslow] = _cspec.cthis * crange( (cpart + 1), cmax_limit );
00772 #ifdef MRASBOBJECT_CPART_ALLOW
00773       _crange[mslow|cfast] = _cspec.cthis * crange( cmin_limit, cpart );
00774       _crange[mfast|cfast] = _cspec.cthis * crange( (cpart + 1), cmax_limit );
00775 #endif
00776 
00777    synchronize();
00778 }

MRAsbObject & MRAsbObject::set_empty (   ) 
 

Definition at line 671 of file MRAsbObject.h.

References MRAsbBase.cspec(), MRAcspec.cthis, MRASBOBJECT_PARTMAX, MRAsbBase.mspec(), MRAmspec.mthis, Part, MRAcrange.set_empty(), MRAmrange.set_empty(), and MRAsbBase.set_empty().

Referenced by set_null(), and store(). 

00672 {
00673    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00674       if ( _ptsb[p] != 0 ) { 
00675          _ptsb[p]->set_empty(); 
00676          _ptsb[p]->mspec().mthis.set_empty();
00677          _ptsb[p]->cspec().cthis.set_empty();
00678       }
00679    }
00680    return *this;
00681 }

void MRAsbObject::set_mpart (  MRAmlevel   ) 
 

Definition at line 723 of file MRAsbObject.h.

References _mrange, cfast, cslow, MRAmlevel.dim(), MRAmpEncode.grid_dim(), mfast, mslow, MRAmspec.mthis, MRAmrange.report(), setstate(), and synchronize(). 

00724 { 
00725    if ( mpart.dim() == _mpenc.grid_dim() ) {
00726 
00727       MRAmlevel mmin_limit( _mpenc.grid_dim() );
00728       MRAmlevel mmax_limit( _mpenc.grid_dim() );
00729 
00730       mmin_limit = MRAmlevel::mmin_limit;
00731       mmax_limit = MRAmlevel::mmax_limit;;
00732 
00733       MRAmrange mrange;
00734 
00735       _mrange[mslow|cslow] = _mspec.mthis * mrange( mmin_limit, mpart );
00736       _mrange[mfast|cslow] = _mspec.mthis * mrange( (mpart + 1), mmax_limit );
00737 #ifdef MRASBOBJECT_CPART_ALLOW
00738       _mrange[mslow|cfast] = _mspec.mthis * mrange( mmin_limit, mpart );
00739       _mrange[mfast|cfast] = _mspec.mthis * mrange( (mpart + 1), mmax_limit );
00740 #endif
00741 
00742       _mrange[mslow|cslow].report();
00743       _mrange[mfast|cslow].report();
00744 
00745       synchronize();
00746 
00747    } else { setstate(failbit); }
00748 }

MRAsbObject & MRAsbObject::set_null (   ) 
 

Definition at line 661 of file MRAsbObject.h.

References set_empty().

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

00662 {
00663    set_empty();
00664    _state = 0;
00665 }

void MRAsbObject::set_storage (  Storage   ) 
 

Definition at line 790 of file MRAsbObject.h.

References _storage, MRASBOBJECT_PARTMAX, Part, Storage, and synchronize(). 

00791 {
00792    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) _storage[p] = storage; 
00793    synchronize();
00794 }

void MRAsbObject::set_storage (  Part  ,
Storage 
) 
 

Definition at line 797 of file MRAsbObject.h.

References _storage, MRASBOBJECT_PARTMAX, Part, Storage, and synchronize(). 

00798 { 
00799    if ( p >= 0 && p < MRASBOBJECT_PARTMAX ) _storage[p] = storage; 
00800    synchronize();
00801 }

void MRAsbObject::setstate (  int   ) 
 

Definition at line 699 of file MRAsbObject.h.

Referenced by create_clone(), and set_mpart(). 

00699 { _state |= s; }

MRAsbObject::Storage MRAsbObject::storage (  Part   ) 
 

Definition at line 804 of file MRAsbObject.h.

References _storage, MRASBOBJECT_PARTMAX, Part, Storage, and unspec. 

00805 {
00806    if ( p >= 0 && p < MRASBOBJECT_PARTMAX ) return _storage[p];
00807    else return unspec;
00808 }

MRAsbObject & MRAsbObject::store (  MRAsbBase &   ) 
 

Definition at line 814 of file MRAsbObject.h.

References _crange, MRAsbBase._cspec, MRAsbBase._datatypecode, _mrange, MRAsbBase._mspec, MRAsbBase._sbn, clear(), MRAsbBase.copy(), MRAsbBase.cspec(), MRAcspec.cthis, MRAsbBase.datatypecode(), MRASBOBJECT_PARTMAX, MRAsbBase.mspec(), MRAmspec.mthis, Part, MRAsbBase.refix_hdr(), MRAsbBase.sbn(), MRAsbBase.set_cspec(), MRAsbBase.set_datatypecode(), set_empty(), MRAsbBase.set_mspec(), MRAsbBase.set_sbn(), and MRAsbBase.unfix_sb().

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

00815 {
00816    clear();
00817    set_empty();
00818 
00819    _sbn = sb._sbn;
00820    _mspec = sb._mspec;
00821    _cspec = sb._cspec;
00822    _datatypecode = sb._datatypecode;
00823 
00824    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
00825       _ptsb[p]->set_sbn( sb.sbn() );
00826 
00827       _ptsb[p]->set_mspec( sb.mspec() );
00828       _ptsb[p]->mspec().mthis = sb.mspec().mthis * _mrange[p];
00829 
00830       _ptsb[p]->set_cspec( sb.cspec() );
00831       _ptsb[p]->cspec().cthis = sb.cspec().cthis * _crange[p];
00832 
00833       _ptsb[p]->set_datatypecode( sb.datatypecode() );
00834       _ptsb[p]->refix_hdr();
00835       _ptsb[p]->unfix_sb();
00836       _ptsb[p]->copy( sb, _mrange[p] );
00837    }
00838 }

void MRAsbObject::synchronize (   )  [private]
 

Definition at line 1026 of file MRAsbObject.h.

References _crange, _mrange, _storage, MRAcspec.cexist, create_clone(), MRAcspec.ctheory, file, MRAsbBase.isa(), mem, MRAmspec.mexist, MRASBOBJECT_PARTMAX, MRAmspec.mtheory, Part, MRAsbBase.set_sbn(), Storage, and store().

Referenced by set_cpart(), set_mpart(), and set_storage(). 

01027 {
01028    MRAsbBase* ptsb;
01029    ptsb = create_clone( Storage(mem) );
01030 
01031    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
01032       if ( _ptsb[p] != 0 ) { delete _ptsb[p]; _ptsb[p] = 0; }
01033    }
01034    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
01035       if ( _storage[p] == mem ) _ptsb[p] = new MRAsb(_mpenc);
01036       else if ( _storage[p] == file ) _ptsb[p] = new MRAsbfstream(_mpenc);
01037       else _ptsb[p] = 0;
01038    }
01039 
01040    store( *ptsb );
01041 
01042    MRAsbBase* tmpptsb;
01043    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) {
01044       if ( _storage[p] == mem && _ptsb[p]->isa() != "MRAsb" ) {
01045          tmpptsb = new MRAsb( *_ptsb[p] );
01046          delete _ptsb[p];
01047          _ptsb[p] = tmpptsb;
01048       } else if ( _storage[p] == file && _ptsb[p]->isa() != "MRAsbfstream" ) {
01049          tmpptsb = new MRAsbfstream( *_ptsb[p] );
01050          delete _ptsb[p];
01051          _ptsb[p] = tmpptsb;
01052       }
01053       if ( _ptsb[p] != 0 ) {
01054          _ptsb[p]->set_sbn( _sbn );
01055 
01056          _ptsb[p]->mspec().mthis *= _mrange[p];
01057          _ptsb[p]->mspec().mexist = _mspec.mexist;;
01058          _ptsb[p]->mspec().mtheory = _mspec.mtheory;;
01059 
01060          _ptsb[p]->cspec().cthis *= _crange[p];
01061          _ptsb[p]->cspec().cexist = _cspec.cexist;;
01062          _ptsb[p]->cspec().ctheory = _cspec.ctheory;;
01063       }
01064    }
01065 }

Friends And Related Function Documentation

friend class MRAsbBase [friend]
 

Definition at line 182 of file MRAsbObject.h.

Field Documentation

MRAcrange MRAsbObject._crange[MRASBOBJECT_PARTMAX] [protected]
 

Definition at line 175 of file MRAsbObject.h.

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

MRAcspec MRAsbObject._cspec [protected]
 

Definition at line 171 of file MRAsbObject.h.

Referenced by copy(), and is_equal().

int MRAsbObject._datatypecode [protected]
 

Definition at line 172 of file MRAsbObject.h.

MRAmpEncode MRAsbObject._mpenc [protected]
 

Definition at line 168 of file MRAsbObject.h.

Referenced by copy(), and is_equal().

MRAmrange MRAsbObject._mrange[MRASBOBJECT_PARTMAX] [protected]
 

Definition at line 174 of file MRAsbObject.h.

Referenced by append(), check_mpart(), copy(), is_equal(), mpart(), MRAsbObject(), operator()(), set_mpart(), store(), and synchronize().

MRAmspec MRAsbObject._mspec [protected]
 

Definition at line 170 of file MRAsbObject.h.

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

MRAsbBase* MRAsbObject._ptsb[MRASBOBJECT_PARTMAX] [protected]
 

Definition at line 177 of file MRAsbObject.h.

Referenced by copy(), and is_equal().

MRAsbn MRAsbObject._sbn [protected]
 

Definition at line 169 of file MRAsbObject.h.

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

int MRAsbObject._state [protected]
 

Definition at line 166 of file MRAsbObject.h.

Referenced by copy(), and is_equal().

Storage MRAsbObject._storage[MRASBOBJECT_PARTMAX] [protected]
 

Definition at line 176 of file MRAsbObject.h.

Referenced by copy(), is_equal(), MRAsbObject(), operator()(), sbsizeb_file(), sbsizeb_mem(), set_storage(), storage(), and synchronize().

const int MRAsbObject.cfast = 0x02 [static]
 

Definition at line 55 of file MRAsbObject.h.

Referenced by help_part(), MRAsbObject(), operator()(), set_cpart(), and set_mpart().

const int MRAsbObject.cslow = 0x00 [static]
 

Definition at line 54 of file MRAsbObject.h.

Referenced by cpart(), help_part(), mpart(), MRAsbObject(), operator()(), set_cpart(), and set_mpart().

const int MRAsbObject.failbit = 0x02 [static]
 

Definition at line 50 of file MRAsbObject.h.

const int MRAsbObject.file = 0x01 [static]
 

Definition at line 58 of file MRAsbObject.h.

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

const int MRAsbObject.goodbit = 0x01 [static]
 

Definition at line 49 of file MRAsbObject.h.

const int MRAsbObject.mem = 0x00 [static]
 

Definition at line 57 of file MRAsbObject.h.

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

const int MRAsbObject.mfast = 0x01 [static]
 

Definition at line 53 of file MRAsbObject.h.

Referenced by help_part(), MRAsbObject(), operator()(), set_cpart(), and set_mpart().

const int MRAsbObject.mslow = 0x00 [static]
 

Definition at line 52 of file MRAsbObject.h.

Referenced by cpart(), help_part(), mpart(), MRAsbObject(), operator()(), set_cpart(), and set_mpart().

const int MRAsbObject.unspec = -1 [static]
 

Definition at line 47 of file MRAsbObject.h.

Referenced by storage().

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