SR2k4 Assembler: MRAsbObject.h Source File

00001 // MRAsbObject.h
00002 //////////////////////////////////////////////////////////////////////
00003 //          (c) Copyright 2002 Brown Deer Technology, LLC.
00004 //                        All rights reserved.
00005 //////////////////////////////////////////////////////////////////////
00006 
00007 #ifndef MRASBOBJECT_H
00008 #define MRASBOBJECT_H
00009 
00010 #ifdef MRASBOBJECT_CPART_ALLOW
00011 #define MRASBOBJECT_PARTMAX 4
00012 #else
00013 #define MRASBOBJECT_PARTMAX 2
00014 #endif
00015 // THIS IS A TEMPORARY MEASURE TO CONTROL THE PARTIONING.
00016 // MRASBOBJECT_PARTMAX 2 shunts the c-partition
00017 // MRASBOBJECT_PARTMAX 4 allows the c-partition
00018 // !!!NOTE!!! allowing c-partition is a disaster if the code
00019 //            is not in place to handle it.  be careful. 
00020 
00021 #ifdef USE_STD
00022 #include <iostream>
00023 #include <algorithm>
00024 using namespace std;
00025 #else
00026 #include <iostream.h>
00027 #include <algorithm.h>
00028 #endif
00029 
00030 #ifndef MRA_MAXDIM
00031 #define MRA_MAXDIM 4
00032 #endif
00033 
00034 #include "MRAsbBase.h"
00035 
00036 class MRAsbObject
00037 {
00038    public:
00039    
00040       void check_mpart() {
00041          cout << "check_mpart\n";
00042          mpart().report();
00043          _mrange[0].report();
00044          _mrange[1].report();
00045       }
00046       
00047       static const int unspec  = -1;
00048 
00049       static const int goodbit = 0x01;
00050       static const int failbit = 0x02;
00051 
00052       static const int mslow = 0x00;
00053       static const int mfast = 0x01;
00054       static const int cslow = 0x00;
00055       static const int cfast = 0x02;
00056 
00057       static const int mem  = 0x00;
00058       static const int file = 0x01;
00059 
00060       typedef int State;
00061       typedef int StateBit;
00062       typedef int Part;
00063       typedef int Storage;
00064 
00065       static string help_part(Part);
00066       static string help_storage(Storage);
00067 
00068       MRAsbObject();
00069       MRAsbObject( const MRAsbObject& );
00070       explicit MRAsbObject( const MRAmpEncode& );
00071       explicit MRAsbObject( MRAsbBase& );
00072       
00073       ~MRAsbObject();
00074 
00075       MRAsbObject& operator () ();
00076       MRAsbObject& operator () ( const MRAsbObject& );
00077       MRAsbObject& operator () ( const MRAmpEncode& );
00078       MRAsbObject& operator () ( MRAsbBase& );
00079 
00080       MRAsbObject& copy( const MRAsbObject& rhs );
00081       MRAsbObject& operator = ( const MRAsbObject& rhs );
00082 
00083       bool is_equal( const MRAsbObject& );
00084       bool operator == ( const MRAsbObject& );
00085       bool operator != ( const MRAsbObject& );
00086 
00087       MRAsbObject& set_null();
00088       bool is_null();
00089       bool operator ! ();
00090 
00091       MRAsbObject& set_empty();
00092       bool is_empty();
00093 
00094       void clear();
00095       void setstate(int);
00096       void clrstate(int);
00097       int rdstate( int = 0xFFFFFFFF );
00098       bool good();
00099       bool fail();
00100 
00101       MRAsbn sbn();
00102       MRAmspec mspec();
00103       MRAcspec cspec();
00104 
00105       void set_mpart( MRAmlevel );
00106       MRAmlevel mpart();
00107 
00108       void set_cpart( MRAclevel );
00109       MRAclevel cpart();
00110 
00111       void set_storage( Part, Storage );
00112       void set_storage( Storage );
00113       Storage storage( Part );
00114 
00115       MRAmpEncode& mpenc();
00116 
00117       MRAsbObject& store( MRAsbBase& );
00118 
00119       MRAsbObject& append( MRAsbBase& );
00120 
00121       MRAsbBase* create_clone( Storage = MRAsbObject::file );
00122       MRAsbBase* create_clone( Part, Storage );
00123       MRAsbBase* create_clone( MRAmrange, Storage = MRAsbObject::file );
00124       MRAsbBase* create_clone( MRAcrange, Storage = MRAsbObject::file );
00125       MRAsbBase* create_clone( 
00126         MRAmrange, MRAcrange, Storage = MRAsbObject::file 
00127       );
00128 
00129       int sbsizeb();
00130       int sbsizeb( const Part p );
00131       int sbsizeb_mem();
00132       int sbsizeb_file();
00133  
00134       template < class Data_t > 
00135       class MStatTable {
00136          public:
00137             MStatTable();
00138             ~MStatTable();
00139             Data_t& operator [] ( int );
00140             int begin() { return MRAmlevel::mmin_limit; }
00141             int end() { return MRAmlevel::mmax_limit; }
00142          private:
00143             Data_t _table [1+MRAmlevel::mmax_limit-MRAmlevel::mmin_limit];
00144       };
00145 
00146       MStatTable<int> mstattable_sbsizeb();
00147 
00148       template < class Data_t > 
00149       class CStatTable {
00150          public:
00151             CStatTable();
00152             ~CStatTable();
00153             Data_t& operator [] ( int );
00154             int begin() { return MRAclevel::cmin_limit; }
00155             int end() { return MRAclevel::cmax_limit; }
00156          private:
00157             Data_t _table [1+MRAclevel::cmax_limit-MRAclevel::cmin_limit];
00158       };
00159 
00160       CStatTable<int> cstattable_sbsizeb();
00161 
00162       void report();
00163 
00164    protected:
00165 
00166       int _state;
00167 
00168       MRAmpEncode _mpenc;
00169       MRAsbn _sbn;
00170       MRAmspec _mspec;
00171       MRAcspec _cspec;
00172       int  _datatypecode;
00173 
00174       MRAmrange _mrange[MRASBOBJECT_PARTMAX];
00175       MRAcrange _crange[MRASBOBJECT_PARTMAX];
00176       Storage _storage[MRASBOBJECT_PARTMAX];
00177       MRAsbBase* _ptsb[MRASBOBJECT_PARTMAX];
00178 
00179    private:
00180       void synchronize();
00181 
00182    friend class MRAsbBase;
00183 
00184 };
00185 
00186 inline
00187 string MRAsbObject::help_part( Part 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 }
00216 
00217 inline
00218 string MRAsbObject::help_storage( Storage 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 }
00230 
00231 inline
00232 MRAsbObject::MRAsbObject() 
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 }
00284 
00285 inline
00286 MRAsbObject::MRAsbObject( const MRAmpEncode& mpenc ) 
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 }
00357 
00358 inline
00359 MRAsbObject::MRAsbObject( MRAsbBase& sb ) 
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 }
00428 
00429 
00430 inline
00431 MRAsbObject::~MRAsbObject() 
00432 {
00433    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p )
00434       if ( _ptsb[p] != 0 ) { delete _ptsb[p]; _ptsb[p] = 0; }
00435 }
00436 
00437 inline
00438 MRAsbObject& MRAsbObject::operator () () 
00439 {  
00440    set_null();
00441 }
00442 
00443 inline
00444 MRAsbObject& MRAsbObject::operator () ( const MRAmpEncode& mpenc )
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 }
00520 
00521 
00522 inline
00523 MRAsbObject& MRAsbObject::operator () ( MRAsbBase& sb )
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 }
00597 
00598 inline
00599 MRAsbObject& MRAsbObject::copy( const MRAsbObject& sbo )
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 }
00623 
00624 inline
00625 MRAsbObject& MRAsbObject::operator = ( const MRAsbObject& rhs ) 
00626 { 
00627    return copy(rhs); 
00628 }
00629 
00630 inline
00631 bool MRAsbObject::is_equal( const MRAsbObject& sbo ) 
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 }
00647 
00648 inline
00649 bool MRAsbObject::operator == ( const MRAsbObject& rhs ) 
00650 { 
00651    return is_equal(rhs); 
00652 }
00653 
00654 inline
00655 bool MRAsbObject::operator != ( const MRAsbObject& rhs )
00656 {
00657    return !is_equal(rhs); 
00658 }
00659 
00660 inline
00661 MRAsbObject& MRAsbObject::set_null() 
00662 {
00663    set_empty();
00664    _state = 0;
00665 }
00666 
00667 inline
00668 bool MRAsbObject::is_null() { return ( _state == 0 ); }
00669 
00670 inline
00671 MRAsbObject& MRAsbObject::set_empty() 
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 }
00682 
00683 inline
00684 bool MRAsbObject::is_empty() 
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 }
00691 
00692 inline
00693 bool MRAsbObject::operator ! () { return is_null(); }
00694 
00695 inline
00696 void MRAsbObject::clear() { _state = goodbit; }
00697 
00698 inline
00699 void MRAsbObject::setstate( int s ) { _state |= s; }
00700 
00701 inline
00702 void MRAsbObject::clrstate( int s ) { _state &= ~s; }
00703 
00704 inline
00705 int MRAsbObject::rdstate( int s ) { return (_state & s); }
00706 
00707 inline
00708 bool MRAsbObject::good() { return _state == goodbit; }
00709 
00710 inline
00711 bool MRAsbObject::fail() { return rdstate(failbit) != 0; }
00712 
00713 inline
00714 MRAsbn MRAsbObject::sbn() { return _sbn; }
00715 
00716 inline
00717 MRAmspec MRAsbObject::mspec() { return _mspec; }
00718 
00719 inline
00720 MRAcspec MRAsbObject::cspec() { return _cspec; }
00721 
00722 inline
00723 void MRAsbObject::set_mpart( MRAmlevel mpart ) 
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 }
00749 
00750 inline
00751 MRAmlevel MRAsbObject::mpart() 
00752 { 
00753    MRAmlevel mpart( _mpenc.grid_dim() );
00754    mpart = _mrange[mslow|cslow].mmax;
00755    return mpart;
00756 }
00757 
00758 inline
00759 void MRAsbObject::set_cpart( MRAclevel cpart )
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 }
00779 
00780 
00781 inline
00782 MRAclevel MRAsbObject::cpart()
00783 { 
00784    MRAclevel cpart;
00785    cpart = _crange[mslow|cslow].cmax;
00786    return cpart;
00787 }
00788 
00789 inline
00790 void MRAsbObject::set_storage( const Storage storage )
00791 {
00792    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) _storage[p] = storage; 
00793    synchronize();
00794 }
00795 
00796 inline
00797 void MRAsbObject::set_storage( const Part p, const Storage storage ) 
00798 { 
00799    if ( p >= 0 && p < MRASBOBJECT_PARTMAX ) _storage[p] = storage; 
00800    synchronize();
00801 }
00802 
00803 inline
00804 MRAsbObject::Storage MRAsbObject::storage( Part p ) 
00805 {
00806    if ( p >= 0 && p < MRASBOBJECT_PARTMAX ) return _storage[p];
00807    else return unspec;
00808 }
00809 
00810 inline
00811 MRAmpEncode& MRAsbObject::mpenc() { return _mpenc; }
00812 
00813 inline
00814 MRAsbObject& MRAsbObject::store( MRAsbBase& sb ) 
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 }
00839 
00840 inline
00841 MRAsbObject& MRAsbObject::append( MRAsbBase& sb )
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 }
00849 
00850 inline
00851 MRAsbBase* MRAsbObject::create_clone( Storage storage )
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 }
00877 
00878 inline
00879 MRAsbBase* MRAsbObject::create_clone( Part p, Storage 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 }
00896 
00897 inline
00898 MRAsbBase* MRAsbObject::create_clone( MRAmrange mrange, Storage 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 }
00926 
00927 inline
00928 MRAsbBase* MRAsbObject::create_clone( MRAcrange crange, Storage 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 }
00956 
00957 inline
00958 MRAsbBase* MRAsbObject::create_clone( 
00959   MRAmrange mrange, MRAcrange crange, Storage storage 
00960 )
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 }
00989 
00990 inline
00991 int MRAsbObject::sbsizeb()
00992 {
00993    int tmp = 0;
00994    for( Part p = 0; p < MRASBOBJECT_PARTMAX; ++p ) tmp += _ptsb[p]->sbsizeb();
00995    return tmp;
00996 }
00997 
00998 inline
00999 int MRAsbObject::sbsizeb( const Part p )
01000 {
01001    if(  p >= 0 && p < MRASBOBJECT_PARTMAX ) return _ptsb[p]->sbsizeb();
01002    else return 0;
01003 }
01004 
01005 inline
01006 int MRAsbObject::sbsizeb_mem()
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 }
01014 
01015 inline
01016 int MRAsbObject::sbsizeb_file()
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 }
01024 
01025 inline
01026 void MRAsbObject::synchronize()
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 }
01066 
01067 template < class Data_t >
01068 MRAsbObject::MStatTable<Data_t>::MStatTable()
01069 {
01070    for( int m = MRAmlevel::mmin_limit; m <=MRAmlevel::mmax_limit; ++m ) {
01071      _table[ m - MRAmlevel::mmin_limit ] = 0;
01072    }
01073 }
01074 
01075 template < class Data_t >
01076 MRAsbObject::MStatTable<Data_t>::~MStatTable() {}
01077 
01078 template < class Data_t >
01079 Data_t& MRAsbObject::MStatTable<Data_t>::operator [] ( int m ) 
01080 { 
01081    return _table[ m - MRAmlevel::mmin_limit ];
01082 }
01083 
01084 inline
01085 MRAsbObject::MStatTable<int> MRAsbObject::mstattable_sbsizeb()
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 }
01109 
01110 template < class Data_t >
01111 MRAsbObject::CStatTable<Data_t>::CStatTable()
01112 {
01113    for( int c = MRAclevel::cmin_limit; c <= MRAclevel::cmax_limit; ++c ) {
01114       _table[ c - MRAclevel::cmin_limit ] = 0;
01115    }
01116 }
01117 
01118 template < class Data_t >
01119 MRAsbObject::CStatTable<Data_t>::~CStatTable() {}
01120 
01121 template < class Data_t >
01122 Data_t& MRAsbObject::CStatTable<Data_t>::operator [] ( int c ) 
01123 { 
01124    if ( c >= MRAclevel::cmin_limit && c <= MRAclevel::cmax_limit ) {
01125       return _table[ c - MRAclevel::cmin_limit ];
01126    }
01127 }
01128 
01129 inline
01130 MRAsbObject::CStatTable<int> MRAsbObject::cstattable_sbsizeb()
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 }
01176 
01177 #endif
01178