00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
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
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
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
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
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
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
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
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
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
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
00241 *( (Tint*)ptr ) = GetRecordSize();
00242 datasize += Tsizeof( Tint );
00243 ( (Tint*)ptr ) ++;
00244
00245
00246
00247 *( (Tobject_t*)ptr ) = theObjectType;
00248 datasize += Tsizeof( Tobject_t );
00249 ( (Tobject_t*)ptr ) ++;
00250
00251
00252
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
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
00362 *( (Tint*)p ) = GetRecordSize();
00363 ( (Tint*)p ) ++;
00364 datasize += Tsizeof( Tint );
00365
00366
00367
00368 *( (Tobject_t*)p ) = theObjectType;
00369 ( (Tobject_t*)p ) ++;
00370 datasize += Tsizeof( Tobject_t );
00371
00372
00373
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
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
00411
00412 ( (Tint*)p ) ++;
00413 datasize += Tsizeof( Tint );
00414
00415
00416
00417 theObjectType = *( (Tobject_t*)p );
00418 ( (Tobject_t*)p ) ++;
00419 datasize += Tsizeof( Tobject_t );
00420
00421
00422
00423
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
00439 Tsize_t nentry = *( (Tsize_t*)p );
00440 ( (Tsize_t*)p ) ++;
00441 datasize += Tsizeof( Tsize_t );
00442
00443
00444
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