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

TDataSegment.cc

解説を見る。
00001 // =====================================================================
00002 //  $Id: TDataSegment.cc,v 1.8 2004/03/07 10:30:30 goiwai Exp $
00003 //  $Name: CLDAQ-1-14-03 $
00004 //  $Log: TDataSegment.cc,v $
00005 //  Revision 1.8  2004/03/07 10:30:30  goiwai
00006 //  ROOTに組みこむためのおまじないマクロを埋めこみました。
00007 //  全てにおいて完全に動作するわけではありません。
00008 //
00009 //  Revision 1.7  2003/12/06 10:59:11  goiwai
00010 //  Serialize(Tvoid*) -> Serialize(const Tvoid*)に変更しました.
00011 //  Deserialize(const Tvoid*)を追加しました.
00012 //  手抜きの実装なので,バッファオーバーフローの可能性があります.
00013 //  Reallocate()とかするような仕組みが必要です.
00014 //
00015 //  Revision 1.6  2003/11/04 12:03:05  goiwai
00016 //  ==演算子と!=演算子を実装しました.具体的には
00017 //  if ( record == "String" ) {
00018 //    hoeghoge;
00019 //  }
00020 //  のような使い方が出来ます.単純に theID メンバとを比較して結果を返します.
00021 //
00022 //  Revision 1.5  2003/10/06 16:42:19  goiwai
00023 //  *** empty log message ***
00024 //
00025 //  Revision 1.4  2003/08/25 09:21:44  goiwai
00026 //  operator[]( const Tstring& id ) を加えました.
00027 //  segment[0] とか segment["tag"] とかすれば, TDataElement を得ることが出
00028 //  来ます.
00029 //  size()を越えた範囲にも,チェックしないでアクセスします.
00030 //  マッチしなかった場合は落ちます.
00031 //  同じ名前でタグされた DataElement がある場合,最初にマッチしたものが返っ
00032 //  てきます.
00033 //
00034 //  Revision 1.3  2003/07/30 16:17:51  goiwai
00035 //  ファイルにコミットログをつけることにしました.
00036 //
00037 // =====================================================================
00038 #include "TDataSegment.hh"
00039 #include "TOutputObjectStream.hh"
00040 #include "TOutputObjectFile.hh"
00041 #include "TOutputObjectSocket.hh"
00042 #include "TOutputObjectSharedMemory.hh"
00043 
00044 TDataSegment::TDataSegment( const Tstring& id )
00045   : TStreamableObject( tObjectDataSegment, id ), TDataElementList()
00046 {;}
00047 
00048 TDataSegment::TDataSegment( const TDataSegment& right )
00049   : TStreamableObject( right ), TDataElementList( right )
00050 {;}
00051 
00052 TDataSegment::~TDataSegment()
00053 {;}
00054 
00055 Tint TDataSegment::GetRecordSize()
00056 {
00057   Tsize_t nchar = theID.size() + 1;
00058   // record size + object type + object id + number of entries
00059   Tint total = Tsizeof( Tint ) + Tsizeof( Tobject_t ) + Tsizeof( Tsize_t ) + ( Tsizeof( Tchar ) * nchar ) + Tsizeof( Tsize_t );
00060   for ( Tsize_t i = 0; i < size(); i ++ ) {
00061     total += ( (*this)[ i ] ).GetRecordSize();
00062   }
00063   return total;
00064 }
00065 
00066 Tint TDataSegment::Record( TOutputObjectStream* output )
00067 {
00068   Tint datasize = 0;
00069   Tstream_t streamtype = output -> GetStreamType();
00070 
00071   switch ( streamtype ) {
00072     case tFileStream:
00073       datasize = record( (TOutputObjectFile*)output );
00074       break;
00075     case tSocketStream:
00076       datasize = record( (TOutputObjectSocket*)output );
00077       break;
00078     case tSharedMemoryStream:
00079       datasize = record( (TOutputObjectSharedMemory*)output );
00080       break;
00081     case tUnknownStream:
00082     default:
00083       Tcerr << "TDataSegment::Record: unknown stream type." << Tendl;
00084       return 0;
00085   }
00086 
00087   for ( Tsize_t i = 0; i < size(); i ++ ) {
00088     datasize += ( (*this)[ i ] ).Record( output );
00089   }
00090 
00091   return datasize;
00092 }
00093 
00094 Tostream& operator<<( Tostream& tos, const TDataSegment& right )
00095 {
00096   tos << "Data Segment(" << right.theObjectType << "), "
00097       << "ID: " << right.theID
00098       << ", Capacity: " << right.capacity()
00099       << ", Entry: " << right.size();
00100 
00101   if ( right.empty() ) {
00102     return tos;
00103   }
00104   
00105   tos << Tendl;
00106 
00107   for ( Tsize_t i = 0; i < right.size(); i ++ ) {
00108     tos << Ttab << Ttab << Ttab << "[" << i << "] " << right[ i ];
00109     if ( i != right.size() - 1 ) {
00110       tos << Tendl;
00111     }
00112   }
00113 
00114   return tos;
00115 }
00116 
00117 Tint TDataSegment::record( TOutputObjectFile* ofile )
00118 {
00119   Tsize_t datasize = 0;
00120   static const Tsize_t nmemb = 1;
00121   Tsize_t ss = 0;
00122   static const Tstring head = "TDataSegment::record";
00123 
00124   // write record size
00125   Tint recsize = GetRecordSize();
00126   ss = fwrite( &recsize, Tsizeof( Tint ), nmemb, ofile -> GetFileStream() );
00127   if ( ss != nmemb ) {
00128     perror( head.c_str() );
00129   } else {
00130     datasize += ss * Tsizeof( Tint );
00131   }
00132 
00133 
00134   // write object type
00135   ss = fwrite( &theObjectType, Tsizeof( Tobject_t ), nmemb, ofile -> GetFileStream() );
00136   if ( ss != nmemb ) {
00137     perror( head.c_str() );
00138   } else {
00139     datasize += ss * Tsizeof( Tobject_t );
00140   }
00141 
00142 
00143   // write object ID
00144   Tchar charbuf;
00145   Tsize_t nchar = theID.size() + 1;
00146   ss = fwrite( &nchar, Tsizeof( Tsize_t ), nmemb, ofile -> GetFileStream() );
00147   if ( ss != nmemb ) {
00148     perror( head.c_str() );
00149   } else {
00150     datasize += ss * Tsizeof( Tsize_t );
00151   }
00152   for ( Tsize_t i = 0; i < nchar; i ++ ) {
00153     if ( i == ( nchar - 1 ) ) {
00154       charbuf = '\0';
00155     } else {
00156       charbuf = theID[ i ];
00157     }
00158     ss = fwrite( &charbuf, Tsizeof( Tchar ), nmemb, ofile -> GetFileStream() );
00159     if ( ss != nmemb ) {
00160       perror( head.c_str() );
00161     } else {
00162       datasize += ss * Tsizeof( Tchar );
00163     }
00164   }
00165 
00166 
00167   // write number of entries
00168   Tsize_t entry = size();
00169   ss = fwrite( &entry, Tsizeof( Tsize_t ), nmemb, ofile -> GetFileStream() );
00170   if ( ss != nmemb ) {
00171     perror( head.c_str() );
00172   } else {
00173     datasize += ss * Tsizeof( Tsize_t );
00174   }
00175 
00176   return (Tint)datasize;
00177 }
00178 
00179 Tint TDataSegment::record( TOutputObjectSocket* osocket )
00180 {
00181   Tsize_t datasize = 0;
00182   static const Tstring head = "TDataSegment::record";
00183 
00184 
00185   // send record size
00186   Tint recsize = GetRecordSize();
00187   if ( send( osocket -> GetServerDescriptor(), &recsize, Tsizeof( Tint ), 0 ) != Tsizeof( Tint ) ) {
00188     perror( head.c_str() );
00189   } else {
00190     datasize += Tsizeof( Tint );
00191   }
00192 
00193 
00194   // send object type
00195   if ( send( osocket -> GetServerDescriptor(), &theObjectType, Tsizeof( Tobject_t ), 0 ) != Tsizeof( Tobject_t ) ) {
00196     perror( head.c_str() );
00197   } else {
00198     datasize += Tsizeof( Tobject_t );
00199   }
00200 
00201 
00202   // send object ID
00203   Tchar charbuf;
00204   Tsize_t nchar = theID.size() + 1;
00205   if ( send( osocket -> GetServerDescriptor(), &nchar, Tsizeof( Tsize_t ), 0 ) != Tsizeof( Tsize_t ) ) {
00206     perror( head.c_str() );
00207   } else {
00208     datasize += Tsizeof( Tsize_t );
00209   }
00210   for ( Tsize_t i = 0; i < nchar; i ++ ) {
00211     if ( i == ( nchar - 1 ) ) {
00212       charbuf = '\0';
00213     } else {
00214       charbuf = theID[ i ];
00215     }
00216     if ( send( osocket -> GetServerDescriptor(), &charbuf, Tsizeof( Tchar ), 0 ) != Tsizeof( Tchar ) ) {
00217       perror( head.c_str() );
00218     } else {
00219       datasize += Tsizeof( Tchar );
00220     }
00221   }
00222 
00223 
00224   // send number of entries
00225   Tsize_t entry = size();
00226   if ( send( osocket -> GetServerDescriptor(), &entry, Tsizeof( Tsize_t ), 0 ) != Tsizeof( Tsize_t ) ) {
00227     perror( head.c_str() );
00228   } else {
00229     datasize += Tsizeof( Tsize_t );
00230   }
00231 
00232   return (Tint)datasize;
00233 }
00234 
00235 Tint TDataSegment::record( TOutputObjectSharedMemory* omemory )
00236 {
00237   Tsize_t datasize = 0;
00238   Tvoid* ptr = omemory -> GetAddress();
00239 
00240   // write record size
00241   *( (Tint*)ptr ) = GetRecordSize();
00242   datasize += Tsizeof( Tint );
00243   ( (Tint*)ptr ) ++;
00244 
00245 
00246   // write object type
00247   *( (Tobject_t*)ptr ) = theObjectType;
00248   datasize += Tsizeof( Tobject_t );
00249   ( (Tobject_t*)ptr ) ++;
00250 
00251 
00252   // write object ID
00253   Tchar charbuf;
00254   Tsize_t nchar = theID.size() + 1;
00255   *( (Tsize_t*)ptr ) = nchar;
00256   datasize += Tsizeof( Tsize_t );
00257   ( (Tsize_t*)ptr ) ++;
00258   for ( Tsize_t i = 0; i < nchar; i ++ ) {
00259     if ( i == ( nchar - 1 ) ) {
00260       charbuf = '\0';
00261     } else {
00262       charbuf = theID[ i ];
00263     }
00264     *( (Tchar*)ptr ) = charbuf;
00265     datasize += Tsizeof( Tchar );
00266     ( (Tchar*)ptr ) ++;
00267   }
00268 
00269 
00270   // write number of entries
00271   Tsize_t entry = size();
00272   *( (Tsize_t*)ptr ) = entry;
00273   datasize += Tsizeof( Tsize_t );
00274   ( (Tsize_t*)ptr ) ++;
00275 
00276 
00277   omemory -> SetAddress( ptr );
00278 
00279   return (Tint)datasize;
00280 }
00281 
00282 
00283 const TDataSegment& TDataSegment::operator=( const TDataSegment& right )
00284 {
00285   *( (TStreamableObject*)this ) = *( (TStreamableObject*)(&right) );
00286   *( (TDataElementList*)this ) = *( (TDataElementList*)(&right) );
00287   return *this;
00288 }
00289 
00290 Tbool TDataSegment::operator==( const TDataSegment& right ) const
00291 {
00292   Tbool ret = Ttrue;
00293   ret &= ( *((TStreamableObject*)this) == *((TStreamableObject*)(&right)) );
00294   ret &= ( *((TDataElementList*)this ) == *( (TDataElementList*)(&right)) );
00295   return ret;
00296 }
00297 
00298 Tbool TDataSegment::operator!=( const TDataSegment& right ) const
00299 {
00300   Tbool ret = Tfalse;
00301   ret |= ( *((TStreamableObject*)this) != *((TStreamableObject*)(&right)) );
00302   ret |= ( *((TDataElementList*)this) != *((TDataElementList*)(&right)) );
00303   return ret;
00304 }
00305 
00306 Tbool TDataSegment::operator==( const Tstring& right ) const
00307 {
00308   if ( theID == right ) {
00309     return Ttrue;
00310   } else {
00311     return Tfalse;
00312   }
00313 }
00314 
00315 Tbool TDataSegment::operator!=( const Tstring& right ) const
00316 {
00317   if ( theID != right ) {
00318     return Ttrue;
00319   } else {
00320     return Tfalse;
00321   }
00322 }
00323 
00324 Tvoid TDataSegment::Clear()
00325 {
00326   theID = TunknownID;
00327   for ( Tsize_t i = 0; i < size(); i ++ )
00328     ( (*this)[ i ] ).Clear();
00329   clear();
00330   return;
00331 }
00332 
00333 Tbool TDataSegment::FindDataElement( const Tstring& id, TDataElement& element ) const
00334 {
00335   for ( Tsize_t i = 0; i < size(); i ++ ) {
00336     if ( ( (*this)[ i ] ).GetID() == id ) {
00337       element = (*this)[ i ];
00338       return Ttrue;
00339     }
00340   }
00341   return Tfalse;
00342 }
00343 
00344 Tint TDataSegment::FindDataElement( const Tstring& id ) const
00345 {
00346   Tint retval = -EFAULT;
00347   for ( Tsize_t i = 0; i < size(); i ++ ) {
00348     if ( ( (*this)[ i ] ).GetID() == id ) {
00349       retval = i;
00350       break;
00351     }
00352   }
00353   return retval;
00354 }
00355 
00356 Tint TDataSegment::Serialize( const Tvoid* buffer )
00357 {
00358   Tvoid* p = const_cast<Tvoid*>(buffer);
00359   Tsize_t datasize = 0;
00360 
00361   // write record size
00362   *( (Tint*)p ) = GetRecordSize();
00363   ( (Tint*)p ) ++;
00364   datasize += Tsizeof( Tint );
00365 
00366 
00367   // write object type
00368   *( (Tobject_t*)p ) = theObjectType;
00369   ( (Tobject_t*)p ) ++;
00370   datasize += Tsizeof( Tobject_t );
00371 
00372 
00373   // write object ID
00374   Tchar charbuf;
00375   Tsize_t nchar = theID.size() + 1;
00376   *( (Tsize_t*)p ) = nchar;
00377   ( (Tsize_t*)p ) ++;
00378   datasize += Tsizeof( Tsize_t );
00379   for ( Tsize_t i = 0; i < nchar; i ++ ) {
00380     if ( i == ( nchar - 1 ) ) {
00381       charbuf = '\0';
00382     } else {
00383       charbuf = theID[ i ];
00384     }
00385     *( (Tchar*)p ) = charbuf;
00386     ( (Tchar*)p ) ++;
00387     datasize += Tsizeof( Tchar );
00388   }
00389 
00390    
00391   // write number of entries
00392   *( (Tsize_t*)p ) = size();
00393   ( (Tsize_t*)p ) ++;
00394   datasize += Tsizeof( Tsize_t );
00395 
00396   for ( Tsize_t i = 0; i < size(); i ++ ) {
00397     Tint d = ( (*this)[ i ] ).Serialize( p );
00398     datasize += d;
00399     (Tbyte*)p += d;
00400   }
00401 
00402   return (Tint)datasize;
00403 }
00404 
00405 Tint TDataSegment::Deserialize( const Tvoid* buffer )
00406 {
00407   Tvoid* p = const_cast<Tvoid*>(buffer);  
00408   Tsize_t datasize = 0;
00409 
00410   // read record size
00411   //SetRecordSize( *( (Tint*)p ) );
00412   ( (Tint*)p ) ++;
00413   datasize += Tsizeof( Tint );
00414 
00415 
00416   // read object type
00417   theObjectType = *( (Tobject_t*)p );
00418   ( (Tobject_t*)p ) ++;
00419   datasize += Tsizeof( Tobject_t );
00420 
00421 
00422 
00423   // read object ID
00424   Tsize_t nchar = *( (Tsize_t*)p );
00425   ( (Tsize_t*)p ) ++;
00426   datasize += Tsizeof( Tsize_t );
00427 
00428   Tchar* cc = new Tchar[ nchar ];
00429   for ( Tsize_t i = 0; i < nchar; i ++ ) {
00430     cc[i] = *( (Tchar*)p );
00431     datasize += Tsizeof( Tchar );
00432     ( (Tchar*)p ) ++;
00433   }
00434   theID = cc;
00435   delete [] cc;
00436 
00437 
00438   // read number of entries
00439   Tsize_t nentry = *( (Tsize_t*)p );
00440   ( (Tsize_t*)p ) ++;
00441   datasize += Tsizeof( Tsize_t );
00442 
00443 
00444   // push dataelement
00445   for ( Tsize_t i = 0; i < nentry; i ++ ) {
00446     TDataElement element;
00447     Tint d = element.Deserialize( p );
00448     this -> push_back( element );
00449     datasize += d;
00450     (Tbyte*)p += d;
00451   }
00452 
00453   return (Tint)datasize;
00454 }
00455 
00456 const TDataElement& TDataSegment::operator[]( Tint n ) const
00457 {
00458   return *( begin() + n );
00459 }
00460 
00461 TDataElement& TDataSegment::operator[]( Tint n )
00462 {
00463   return *( begin() + n );
00464 }
00465 
00466 const TDataElement& TDataSegment::operator[]( const Tstring& id ) const
00467 {
00468   return (*this)[ FindDataElement( id ) ];
00469 }
00470 
00471 TDataElement& TDataSegment::operator[]( const Tstring& id )
00472 {
00473   return (*this)[ FindDataElement( id ) ];
00474 }
00475 
00476 #ifdef __CLDAQ_ROOT_DLL
00477     ClassImp(TDataSegment)
00478 #endif


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