メインページ   モジュール   名前空間一覧   クラス階層   アルファベット順一覧   構成   ファイル一覧   構成メンバ   ファイルメンバ   関連ページ    

TInputObjectFile.cc

解説を見る。
00001 // =====================================================================
00002 //  $Id: TInputObjectFile.cc,v 1.9 2004/03/07 10:30:32 goiwai Exp $
00003 //  $Name: CLDAQ-1-14-03 $
00004 //  $Log: TInputObjectFile.cc,v $
00005 //  Revision 1.9  2004/03/07 10:30:32  goiwai
00006 //  ROOTに組みこむためのおまじないマクロを埋めこみました。
00007 //  全てにおいて完全に動作するわけではありません。
00008 //
00009 //  Revision 1.8  2003/12/06 10:56:19  goiwai
00010 //  フィルタ関連の修整と Read(),Write()の戻り値の修整です.
00011 //  Read()もWrite()も処理したレコードサイズを返します.
00012 //  フィルタがある場合も同様です.
00013 //  それぞれのストリームのDataSizeの扱いですが,これは扱ったレコードサイズ
00014 //  でなく扱ったファイルやソケットなどのサイズになります.レコードサイズと
00015 //  一致するとは限りません.
00016 //
00017 //  Revision 1.7  2003/11/27 07:34:54  goiwai
00018 //  TInputObjectFile::operator[](index)の挙動がおかしかったので直しました.
00019 //  そしてちょっとだけ高速化しました.
00020 //  これであらかたバグはつぶしたと思うんですけど...
00021 //
00022 //  Revision 1.6  2003/11/24 22:38:50  goiwai
00023 //  Size(),operator[int]を使ったときに異常に遅くなる問題を解消しました.
00024 //  ストリームからの読みだしサイズが実際のファイルサイズと一致しない問題を
00025 //  解決しました.
00026 //
00027 //  Revision 1.5  2003/11/24 07:06:23  goiwai
00028 //  operator[]( const Tstring& id ) と operator[]( Tint index ) を実装しま
00029 //  した.
00030 //  stream["TAG"] や stream[index] でレコードが取りだせます.
00031 //
00032 //  Revision 1.4  2003/10/12 13:04:56  goiwai
00033 //  ファイルの終端に到達するか読みこみに失敗したときには 0 を返すようにし
00034 //  ました.オフラインではこれで十分でしょう.
00035 //  while ( stream -> Read( record ) ) {
00036 //    ;
00037 //  }
00038 //
00039 //  Revision 1.3  2003/10/06 17:02:42  goiwai
00040 //  *** empty log message ***
00041 //
00042 //  Revision 1.2  2003/07/30 16:19:30  goiwai
00043 //  ファイルにコミットログをつけることにしました.
00044 //
00045 // =====================================================================
00046 #include "TInputObjectFile.hh"
00047 #include "TStreamableObject.hh"
00048 #include "TDataRecord.hh"
00049 #include "TDataSection.hh"
00050 #include "TDataSegment.hh"
00051 #include "TDataElement.hh"
00052 #include "TInputObjectFilter.hh"
00053 
00054 TInputObjectFile::TInputObjectFile( const Tstring& filename, const Tstring& mode )
00055   : TObjectFile( filename, mode ), 
00056     TInputObjectStream( tFileStream )
00057 {;}
00058 
00059 TInputObjectFile::TInputObjectFile( TInputObjectFilter* filter, const Tstring& filename, const Tstring& mode )
00060   : TObjectFile( filename, mode ), 
00061     TInputObjectStream( filter, tFileStream )
00062 {;}
00063 
00064 TInputObjectFile::~TInputObjectFile()
00065 {;}
00066 
00067 Tint TInputObjectFile::Read( TStreamableObject& object )
00068 {
00069   if ( HasFilter() ) {
00070     return theObjectFilter -> Filtering( object, this );
00071   }  
00072 
00073   theLastDataSize = theDataSize;
00074   theDataSize = 0;
00075 
00076   static Tobject_t objecttype = object.GetObjectType();
00077 
00078   switch ( objecttype ) {
00079     case tObjectDataRecord:
00080       *( (TDataRecord*)(&object) ) = getDataRecord();
00081       break;
00082     case tObjectDataSection:
00083       *( (TDataSection*)(&object) ) = getDataSection();
00084       break;
00085     case tObjectDataSegment:
00086       *( (TDataSegment*)(&object) ) = getDataSegment();
00087       break;
00088     case tObjectDataElement:
00089       *( (TDataElement*)(&object) ) = getDataElement();
00090       break;
00091     default:
00092       break;
00093   }
00094 
00095   if ( theDataSize <= 0 ) {
00096     SetOffset( theTotalDataSize, TObjectFile::tSeekBegin );
00097     theDataSize = 0;
00098   } else {
00099     theTotalDataSize += theDataSize;
00100   }
00101 
00102   return theDataSize;
00103 }
00104 
00105 TDataRecord TInputObjectFile::getDataRecord()
00106 {
00107   Tint recsize;
00108   Tobject_t type;
00109   Tstring id;
00110   Tsize_t entries;
00111 
00112   readProperties( recsize, type, id, entries );
00113 
00114   TDataRecord record( id );
00115   record.SetObjectType( type );
00116   if ( theDataSize == 0 ) {
00117     return record;
00118   }
00119 
00120   for ( Tsize_t i = 0; i < entries; i ++ ) {
00121     record.push_back( getDataSection() );
00122   }
00123 
00124   return record;
00125 }
00126 
00127 TDataSection TInputObjectFile::getDataSection()
00128 {
00129   Tint recsize;
00130   Tobject_t type;
00131   Tstring id;
00132   Tsize_t entries;
00133   readProperties( recsize, type, id, entries );
00134 
00135   TDataSection section( id );
00136   section.SetObjectType( type );
00137   if ( theDataSize == 0 ) {
00138     return section;
00139   }
00140 
00141   for ( Tsize_t i = 0; i < entries; i ++ ) {
00142     section.push_back( getDataSegment() );
00143   }
00144 
00145   return section;
00146 }
00147 
00148 TDataSegment TInputObjectFile::getDataSegment()
00149 {
00150   Tint recsize;
00151   Tobject_t type;
00152   Tstring id;
00153   Tsize_t entries;
00154   readProperties( recsize, type, id, entries );
00155 
00156 
00157   TDataSegment segment( id );
00158   segment.SetObjectType( type );
00159   if ( theDataSize == 0 ) {
00160     return segment;
00161   }
00162 
00163   for ( Tsize_t i = 0; i < entries; i ++ ) {
00164     segment.push_back( getDataElement() );
00165   }
00166 
00167   return segment;
00168 }
00169 
00170 TDataElement TInputObjectFile::getDataElement()
00171 {
00172   static const Tsize_t nmemb = 1;
00173   static const Tstring head = "TInputObjectFile::getDataElement";
00174   Tint recsize;
00175   Tobject_t otype;
00176   Tstring id;
00177   Telement_t etype;
00178   Tint nprvs;
00179   TDataElement element;
00180 
00181 
00182   // read record size
00183   if ( ( fread( &recsize, Tsizeof( Tint ), nmemb, theFileStream ) != nmemb ) ) {
00184     //perror( head.c_str() );
00185     SetOffset( 0, TObjectFile::tSeekEnd );
00186     theDataSize = 0;
00187     return element;
00188   } else {
00189     theDataSize += Tsizeof( Tint );
00190   }
00191 
00192 
00193   // read object type
00194   if ( ( fread( &otype, Tsizeof( Tobject_t ), nmemb, theFileStream ) != nmemb ) ) {
00195     //perror( head.c_str() );
00196     SetOffset( 0, TObjectFile::tSeekEnd );
00197     theDataSize = 0;
00198     return element;
00199   } else {
00200     theDataSize += Tsizeof( Tobject_t );
00201     element.SetObjectType( otype );
00202   }
00203 
00204 
00205   // read object id
00206   Tsize_t nchar;
00207   Tchar* charbuf = 0;
00208   if ( fread( &nchar, Tsizeof( Tsize_t ), nmemb, theFileStream ) != nmemb ) {
00209     //perror( head.c_str() );
00210     SetOffset( 0, TObjectFile::tSeekEnd );
00211     theDataSize = 0;
00212     return element;
00213   } else {
00214     theDataSize += Tsizeof( Tsize_t );
00215     charbuf = new Tchar[ nchar ];
00216   }
00217   if ( fread( charbuf, Tsizeof( Tchar ) * nchar, nmemb, theFileStream ) != nmemb ) {
00218     //perror( head.c_str() );
00219     SetOffset( 0, TObjectFile::tSeekEnd );
00220     theDataSize = 0;
00221     delete [] charbuf;
00222     return element;
00223   } else {
00224     theDataSize += Tsizeof( Tchar ) * nchar;
00225     id = charbuf;
00226     delete [] charbuf;
00227     element.SetID( id );
00228   }
00229 
00230 
00231 
00232   // read element type
00233   if ( ( fread( &etype, Tsizeof( Telement_t ), nmemb, theFileStream ) != nmemb ) ) {
00234     //perror( head.c_str() );
00235     SetOffset( 0, TObjectFile::tSeekEnd );
00236     theDataSize = 0;
00237     return element;
00238   } else {
00239     theDataSize += Tsizeof( Telement_t );
00240     element.SetElementType( etype );
00241   }
00242 
00243 
00244   // read number of primitives
00245   if ( ( fread( &nprvs, Tsizeof( Tint ), nmemb, theFileStream ) != nmemb ) ) {
00246     //perror( head.c_str() );
00247     SetOffset( 0, TObjectFile::tSeekEnd );
00248     theDataSize = 0;
00249     return element;
00250   } else {
00251     theDataSize += Tsizeof( Tint );
00252     element.SetNumberOfPrimitives( nprvs );
00253   }
00254 
00255 
00256   Tstring* strbuf = 0;
00257   Tchar* cc = 0;
00258   Tint* ii = 0;
00259   TUint* ui = 0;
00260   Tdouble* dd = 0;
00261   TUshort* us = 0;
00262   Tshort* ss = 0;
00263   Tfloat* ff = 0;
00264   Tlong* ll = 0;
00265   TUlong* ul = 0;
00266 
00267 
00268 
00269   switch ( etype ) {
00270 
00271     case tTypeInt:
00272       ii = new Tint[ nprvs ];
00273       if ( fread( ii, Tsizeof( Tint ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00274         //perror( head.c_str() );
00275         SetOffset( 0, TObjectFile::tSeekEnd );
00276         theDataSize = 0;
00277         delete [] ii;
00278         return element;
00279       } else {
00280         element.FillData( ii, nprvs );
00281         theDataSize += (Tint)( Tsizeof( Tint ) * nprvs );
00282         delete [] ii;
00283       }
00284       break;
00285 
00286 
00287     case tTypeUnsignedInt:
00288       ui = new TUint[ nprvs ];
00289       if ( fread( ui, Tsizeof( TUint ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00290         //perror( head.c_str() );
00291         SetOffset( 0, TObjectFile::tSeekEnd );
00292         theDataSize = 0;
00293         delete [] ui;
00294         return element;
00295       } else {
00296         element.FillData( ui, nprvs );
00297         theDataSize += (Tint)( Tsizeof( TUint ) * nprvs );
00298         delete [] ui;
00299       }
00300       break;
00301 
00302 
00303     case tTypeWord:
00304     case tTypeUnsignedShort:
00305       us = new TUshort[ nprvs ];
00306       if ( fread( us, Tsizeof( TUshort ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00307         //perror( head.c_str() );
00308         SetOffset( 0, TObjectFile::tSeekEnd );
00309         theDataSize = 0;
00310         delete [] us;
00311         return element;
00312       } else {
00313         element.FillData( us, nprvs );
00314         theDataSize += (Tint)( Tsizeof( TUshort ) * nprvs );
00315         delete [] us;
00316       }
00317       break;
00318 
00319     case tTypeDouble:
00320       dd = new Tdouble[ nprvs ];
00321       if ( fread( dd, Tsizeof( Tdouble ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00322         //perror( head.c_str() );
00323         SetOffset( 0, TObjectFile::tSeekEnd );
00324         theDataSize = 0;
00325         delete [] dd;
00326         return element;
00327       } else {
00328         element.FillData( dd, nprvs );
00329         theDataSize += (Tint)( Tsizeof( Tdouble ) * nprvs );
00330         delete [] dd;
00331       }
00332       break;
00333 
00334     case tTypeFloat:
00335       ff = new Tfloat[ nprvs ];
00336 
00337       if ( fread( ff, Tsizeof( Tfloat ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00338         //perror( head.c_str() );
00339         SetOffset( 0, TObjectFile::tSeekEnd );
00340         theDataSize = 0;
00341         delete [] ff;
00342         return element;
00343       } else {
00344         element.FillData( ff, nprvs );
00345         theDataSize += (Tint)( Tsizeof( Tfloat ) * nprvs );
00346         delete [] ff;
00347       }
00348       break;
00349 
00350 
00351     case tTypeShort:
00352       ss = new Tshort[ nprvs ];
00353       if ( fread( ss, Tsizeof( Tshort ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00354         //perror( head.c_str() );
00355         SetOffset( 0, TObjectFile::tSeekEnd );
00356         theDataSize = 0;
00357         delete [] ss;
00358         return element;
00359       } else {
00360         element.FillData( ss, nprvs );
00361         theDataSize += (Tint)( Tsizeof( Tshort ) * nprvs );
00362         delete [] ss;
00363       }
00364       break;
00365 
00366     case tTypeLong:
00367       ll = new Tlong[ nprvs ];
00368       if ( fread( ll, Tsizeof( Tlong ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00369         //perror( head.c_str() );
00370         SetOffset( 0, TObjectFile::tSeekEnd );
00371         theDataSize = 0;
00372         delete [] ll;
00373         return element;
00374       } else {
00375         element.FillData( ll, nprvs );
00376         theDataSize += (Tint)( Tsizeof( Tlong ) * nprvs );
00377         delete [] ll;
00378       }
00379       break;
00380 
00381     case tTypeUnsignedLong:
00382       ul = new TUlong[ nprvs ];
00383       if ( fread( ul, Tsizeof( TUlong ) * nprvs, nmemb, theFileStream ) != nmemb ) {
00384         //perror( head.c_str() );
00385         SetOffset( 0, TObjectFile::tSeekEnd );
00386         theDataSize = 0;
00387         delete [] ul;
00388         return element;
00389       } else {
00390         element.FillData( ul, nprvs );
00391         theDataSize += (Tint)( Tsizeof( TUlong ) * nprvs );
00392         delete [] ul;
00393       }
00394       break;
00395 
00396     case tTypeString:
00397       strbuf = new Tstring[ nprvs ];
00398       for ( Tint i = 0; i < nprvs; i ++ ) {
00399         Tsize_t nchar;
00400         if ( fread( &nchar, Tsizeof( Tsize_t ), nmemb, theFileStream ) != nmemb ) {
00401           //perror( head.c_str() );
00402           SetOffset( 0, TObjectFile::tSeekEnd );
00403           theDataSize = 0;
00404           delete [] strbuf;
00405           return element;
00406         } else {
00407           theDataSize += (Tint)( Tsizeof( Tsize_t ) * nmemb );
00408           cc = new Tchar[ nchar ];
00409         }
00410         if ( fread( cc, Tsizeof( Tchar ) * nchar, nmemb, theFileStream ) != nmemb ) {
00411           //perror( head.c_str() );
00412           SetOffset( 0, TObjectFile::tSeekEnd );
00413           theDataSize = 0;
00414           delete [] cc;
00415           delete [] strbuf;
00416           return element;
00417         } else {
00418           theDataSize += (Tint)( Tsizeof( Tchar ) * nchar );
00419         }
00420         strbuf[ i ] = cc;
00421         delete [] cc;
00422       }
00423       element.FillData( strbuf, nprvs );
00424       delete [] strbuf;
00425       break;
00426 
00427     case tTypeUnknown:
00428     case tTypeObject:
00429     default:
00430       break;
00431   }
00432 
00433   return element;
00434 }
00435 
00436 Tvoid TInputObjectFile::readProperties( Tint& recsize, Tobject_t& type, Tstring& id, Tsize_t& entries )
00437 {
00438   static const Tsize_t nmemb = 1;
00439   static const Tstring head = "TInputObjectFile::readProperties";
00440 
00441   // read record size
00442   if ( ( fread( &recsize, Tsizeof( Tint ), nmemb, theFileStream ) != nmemb ) ) {
00443     //perror( head.c_str() );
00444     SetOffset( 0, TObjectFile::tSeekEnd );
00445     theDataSize = 0;
00446     return;
00447   } else {
00448     theDataSize += Tsizeof( Tint );
00449   }
00450 
00451 
00452   // read object type
00453   if ( ( fread( &type, Tsizeof( Tobject_t ), nmemb, theFileStream ) != nmemb ) ) {
00454     //perror( head.c_str() );
00455     SetOffset( 0, TObjectFile::tSeekEnd );
00456     theDataSize = 0;
00457     return;
00458   } else {
00459     theDataSize += Tsizeof( Tobject_t );
00460   }
00461 
00462   // read object id
00463   Tsize_t nchar;
00464   Tchar* charbuf = 0;
00465   if ( fread( &nchar, Tsizeof( Tsize_t ), nmemb, theFileStream ) != nmemb ) {
00466     //perror( head.c_str() );
00467     SetOffset( 0, TObjectFile::tSeekEnd );
00468     theDataSize = 0;
00469     return;
00470   } else {
00471     theDataSize += Tsizeof( Tsize_t );
00472     charbuf = new Tchar[ nchar ];
00473   }
00474   if ( fread( charbuf, Tsizeof( Tchar ) * nchar, nmemb, theFileStream ) != nmemb ) {
00475     //perror( head.c_str() );
00476     SetOffset( 0, TObjectFile::tSeekEnd );
00477     theDataSize = 0;
00478     delete [] charbuf;
00479     return;
00480   } else {
00481     theDataSize += Tsizeof( Tchar ) * nchar;
00482   }
00483   id = charbuf;
00484   delete [] charbuf;
00485 
00486   // read entries
00487   if ( ( fread( &entries, Tsizeof( Tsize_t ), nmemb, theFileStream ) != nmemb ) ) {
00488     //perror( head.c_str() );
00489     SetOffset( 0, TObjectFile::tSeekEnd );
00490     theDataSize = 0;
00491     return;
00492   } else {
00493     theDataSize += Tsizeof( Tsize_t );
00494   }
00495 
00496   return;
00497 }
00498 
00499 TDataRecord TInputObjectFile::operator[]( const Tstring& id )
00500 {
00501   TDataRecord retval;
00502   Tint pos = Find( id, GetOffset() );
00503   //Tint pos = Find( id );
00504   if ( pos >= 0 ) {
00505     theLastDataSize = theDataSize;
00506     theDataSize = 0;  
00507     retval = getDataRecord();
00508     theTotalDataSize += theDataSize;
00509   }
00510   return retval;
00511 }
00512 
00513 TDataRecord TInputObjectFile::operator[]( Tint index )
00514 {
00515   TDataRecord retval;
00516   Tint pos = Find( index );
00517 
00518   if ( pos >= 0 ) {
00519     SetOffset( pos, tSeekBegin );
00520     theLastDataSize = theDataSize;
00521     theDataSize = 0;
00522     retval = getDataRecord();
00523     theTotalDataSize += theDataSize;
00524   }
00525   return retval;
00526 }
00527 
00528 #ifdef __CLDAQ_ROOT_DLL
00529     ClassImp(TInputObjectFile)
00530 #endif


CLDAQ - a Class Library for DataAcQuisition (Version 1.14.3)
Go IWAI -- goiwai at users.sourceforge.jp