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
00039
00040
00041
00042
00043
00044
00045
00046
00047 #include "TDataElement.hh"
00048 #include "TOutputObjectStream.hh"
00049 #include "TOutputObjectFile.hh"
00050 #include "TOutputObjectSocket.hh"
00051 #include "TOutputObjectSharedMemory.hh"
00052
00053 TDataElement::TDataElement( Telement_t type, const Tstring& id )
00054 : TStreamableObject( tObjectDataElement, id ),
00055 theData( 0 ), theElementType( type ), theNumberOfPrimitives( 0 )
00056 {;}
00057
00058 TDataElement::TDataElement( Tvoid* data, Telement_t type, const Tstring& id, Tint ndata )
00059 : TStreamableObject( tObjectDataElement, id ),
00060 theData( 0 ), theElementType( type ), theNumberOfPrimitives( ndata )
00061 {
00062 allocateDataSpace( data );
00063 }
00064
00065 TDataElement::TDataElement( const TDataElement& right )
00066 : TStreamableObject( right ),
00067 theData( 0 ), theElementType( right.theElementType ),
00068 theNumberOfPrimitives( right.theNumberOfPrimitives )
00069 {
00070 allocateDataSpace( right.theData );
00071 }
00072
00073 TDataElement::~TDataElement()
00074 {
00075 freeDataSpace();
00076 }
00077
00078 Tint TDataElement::Record( TOutputObjectStream* output )
00079 {
00080 Tint datasize = 0;
00081 Tstream_t streamtype = output -> GetStreamType();
00082
00083 switch ( streamtype ) {
00084 case tFileStream:
00085 datasize = record( (TOutputObjectFile*)output );
00086 break;
00087 case tSocketStream:
00088 datasize = record( (TOutputObjectSocket*)output );
00089 break;
00090 case tSharedMemoryStream:
00091 datasize = record( (TOutputObjectSharedMemory*)output );
00092 break;
00093 case tUnknownStream:
00094 default:
00095 Tcerr << "TDataElement::Record: unknown stream type." << Tendl;
00096 return 0;
00097 }
00098
00099 return datasize;
00100 }
00101
00102 Tint TDataElement::GetRecordSize()
00103 {
00104 Tsize_t nchar = theID.size() + 1;
00105
00106 Tint total = Tsizeof( Tint ) + Tsizeof( Tobject_t ) + Tsizeof( Tsize_t ) + ( Tsizeof( Tchar ) * nchar ) + Tsizeof( Telement_t ) + Tsizeof( Tint );
00107
00108 switch ( theElementType ) {
00109 case tTypeInt:
00110 total += ( Tsizeof( Tint ) ) * theNumberOfPrimitives;
00111 break;
00112 case tTypeUnsignedInt:
00113 total += ( Tsizeof( TUint ) ) * theNumberOfPrimitives;
00114 break;
00115 case tTypeWord:
00116 case tTypeUnsignedShort:
00117 total += ( Tsizeof( TUshort ) ) * theNumberOfPrimitives;
00118 break;
00119 case tTypeDouble:
00120 total += ( Tsizeof( Tdouble ) ) * theNumberOfPrimitives;
00121 break;
00122 case tTypeFloat:
00123 total += ( Tsizeof( Tfloat ) ) * theNumberOfPrimitives;
00124 break;
00125 case tTypeShort:
00126 total += ( Tsizeof( Tshort ) ) * theNumberOfPrimitives;
00127 break;
00128 case tTypeLong:
00129 total += ( Tsizeof( Tlong ) ) * theNumberOfPrimitives;
00130 break;
00131 case tTypeUnsignedLong:
00132 total += ( Tsizeof( TUlong ) ) * theNumberOfPrimitives;
00133 break;
00134 case tTypeString:
00135 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00136 total += ( Tsizeof( Tsize_t ) );
00137 Tsize_t ss = ( ( (Tstring*)theData )[ i ] ).size() + 1;
00138 total += ( Tsizeof( Tchar ) ) * ss;
00139 }
00140 break;
00141 case tTypeUnknown:
00142 case tTypeObject:
00143 default:
00144 break;
00145 }
00146
00147
00148 return (Tint)total;
00149 }
00150
00151 const TDataElement& TDataElement::operator=( const TDataElement& right )
00152 {
00153 *( (TStreamableObject*)this ) = *( (TStreamableObject*)(&right) );
00154
00155 freeDataSpace();
00156
00157 theElementType = right.theElementType;
00158 theNumberOfPrimitives = right.theNumberOfPrimitives;
00159
00160 allocateDataSpace( right.theData );
00161
00162 return *this;
00163 }
00164
00165 Tbool TDataElement::operator==( const TDataElement& right ) const
00166 {
00167 Tbool ret = Ttrue;
00168 ret &= ( *((TStreamableObject*)this) == *( (TStreamableObject*)(&right) ) );
00169 ret &= ( theElementType == right.theElementType );
00170 ret &= ( theNumberOfPrimitives == right.theNumberOfPrimitives );
00171
00172 if ( ret != Tfalse ) {
00173 switch ( theElementType ) {
00174 case tTypeInt:
00175 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00176 ret &= ( ((Tint*)theData)[ i ] == ((Tint*)(right.theData))[ i ] );
00177 if ( ret == Tfalse ) {
00178 break;
00179 }
00180 }
00181 break;
00182 case tTypeUnsignedInt:
00183 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00184 ret &= ( ((TUint*)theData)[ i ] == ((TUint*)(right.theData))[ i ] );
00185 if ( ret == Tfalse ) {
00186 break;
00187 }
00188 }
00189 break;
00190 case tTypeUnsignedShort:
00191 case tTypeWord:
00192 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00193 ret &= ( ((TUshort*)theData)[ i ] == ((TUshort*)(right.theData))[ i ] );
00194 if ( ret == Tfalse ) {
00195 break;
00196 }
00197 }
00198 break;
00199 case tTypeDouble:
00200 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00201 ret &= ( ((Tdouble*)theData)[ i ] == ((Tdouble*)(right.theData))[ i ] );
00202 if ( ret == Tfalse ) {
00203 break;
00204 }
00205 }
00206 break;
00207 case tTypeFloat:
00208 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00209 ret &= ( ((Tfloat*)theData)[ i ] == ((Tfloat*)(right.theData))[ i ] );
00210 if ( ret == Tfalse ) {
00211 break;
00212 }
00213 }
00214 break;
00215 case tTypeShort:
00216 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00217 ret &= ( ((Tshort*)theData)[ i ] == ((Tshort*)(right.theData))[ i ] );
00218 if ( ret == Tfalse ) {
00219 break;
00220 }
00221 }
00222 break;
00223 case tTypeLong:
00224 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00225 ret &= ( ((Tlong*)theData)[ i ] == ((Tlong*)(right.theData))[ i ] );
00226 if ( ret == Tfalse ) {
00227 break;
00228 }
00229 }
00230 break;
00231 case tTypeUnsignedLong:
00232 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00233 ret &= ( ((TUlong*)theData)[ i ] == ((TUlong*)(right.theData))[ i ] );
00234 if ( ret == Tfalse ) {
00235 break;
00236 }
00237 }
00238 break;
00239 case tTypeString:
00240 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00241 ret &= ( ((Tstring*)theData)[ i ] == ((Tstring*)(right.theData))[ i ] );
00242 if ( ret == Tfalse ) {
00243 break;
00244 }
00245 }
00246 break;
00247 case tTypeUnknown:
00248 case tTypeObject:
00249 default:
00250 ret &= Tfalse;
00251 break;
00252 }
00253 }
00254 return ret;
00255 }
00256
00257 Tbool TDataElement::operator!=( const TDataElement& right ) const
00258 {
00259 Tbool ret = Tfalse;
00260 ret |= ( *((TStreamableObject*)this) != *((TStreamableObject*)(&right)) );
00261 ret |= ( theElementType != right.theElementType );
00262 ret |= ( theNumberOfPrimitives != right.theNumberOfPrimitives );
00263
00264
00265 if ( ret == Tfalse ) {
00266 switch ( theElementType ) {
00267 case tTypeInt:
00268 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00269 ret |= ( ((Tint*)theData)[ i ] != ((Tint*)(right.theData))[ i ] );
00270 if ( ret == Ttrue )
00271 break;
00272 }
00273 break;
00274 case tTypeUnsignedInt:
00275 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00276 ret |= ( ((TUint*)theData)[ i ] != ((TUint*)(right.theData))[ i ] );
00277 if ( ret == Ttrue )
00278 break;
00279 }
00280 break;
00281 case tTypeUnsignedShort:
00282 case tTypeWord:
00283 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00284 ret |= ( ((TUshort*)theData)[ i ] != ((TUshort*)(right.theData))[ i ] );
00285 if ( ret == Ttrue )
00286 break;
00287 }
00288 break;
00289 case tTypeDouble:
00290 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00291 ret |= ( ((Tdouble*)theData)[ i ] != ((Tdouble*)(right.theData))[ i ] );
00292 if ( ret == Ttrue )
00293 break;
00294 }
00295 break;
00296 case tTypeFloat:
00297 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00298 ret |= ( ((Tfloat*)theData)[ i ] != ((Tfloat*)(right.theData))[ i ] );
00299 if ( ret == Ttrue )
00300 break;
00301 }
00302 break;
00303 case tTypeShort:
00304 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00305 ret |= ( ((Tshort*)theData)[ i ] != ((Tshort*)(right.theData))[ i ] );
00306 if ( ret == Ttrue )
00307 break;
00308 }
00309 break;
00310 case tTypeLong:
00311 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00312 ret |= ( ((Tlong*)theData)[ i ] != ((Tlong*)(right.theData))[ i ] );
00313 if ( ret == Ttrue )
00314 break;
00315 }
00316 break;
00317 case tTypeUnsignedLong:
00318 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00319 ret |= ( ((TUlong*)theData)[ i ] != ((TUlong*)(right.theData))[ i ] );
00320 if ( ret == Ttrue )
00321 break;
00322 }
00323 break;
00324 case tTypeString:
00325 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00326 ret |= ( ((Tstring*)theData)[ i ] != ((Tstring*)(right.theData))[ i ] );
00327 if ( ret == Ttrue )
00328 break;
00329 }
00330 break;
00331 case tTypeUnknown:
00332 case tTypeObject:
00333 default:
00334 ret |= Ttrue;
00335 break;
00336 }
00337 }
00338 return ret;
00339 }
00340
00341 Tbool TDataElement::operator==( const Tstring& right ) const
00342 {
00343 if ( theID == right ) {
00344 return Ttrue;
00345 } else {
00346 return Tfalse;
00347 }
00348 }
00349
00350 Tbool TDataElement::operator!=( const Tstring& right ) const
00351 {
00352 if ( theID != right ) {
00353 return Ttrue;
00354 } else {
00355 return Tfalse;
00356 }
00357 }
00358
00359 Tint TDataElement::record( TOutputObjectFile* ofile )
00360 {
00361 Tsize_t datasize = 0;
00362 static const Tsize_t nmemb = 1;
00363 static const Tstring head = "TDataElement::record";
00364 Tsize_t ss = 0;
00365
00366
00367
00368 Tint recsize = GetRecordSize();
00369 ss = fwrite( &recsize, Tsizeof( Tint ), nmemb, ofile -> GetFileStream() );
00370 if ( ss != nmemb ) {
00371 perror( head.c_str() );
00372 } else {
00373 datasize += ss * Tsizeof( Tint );
00374 }
00375
00376
00377
00378
00379 ss = fwrite( &theObjectType, Tsizeof( Tobject_t ), nmemb, ofile -> GetFileStream() );
00380 if ( ss != nmemb ) {
00381 perror( head.c_str() );
00382 } else {
00383 datasize += ss * Tsizeof( Tobject_t );
00384 }
00385
00386
00387
00388 Tchar charbuf;
00389 Tsize_t nchar = theID.size() + 1;
00390 ss = fwrite( &nchar, Tsizeof( Tsize_t ), nmemb, ofile -> GetFileStream() );
00391 if ( ss != nmemb ) {
00392 perror( head.c_str() );
00393 } else {
00394 datasize += ss * Tsizeof( Tsize_t );
00395 }
00396 for ( Tsize_t i = 0; i < nchar; i ++ ) {
00397 if ( i == ( nchar - 1 ) ) {
00398 charbuf = '\0';
00399 } else {
00400 charbuf = theID[ i ];
00401 }
00402 ss = fwrite( &charbuf, Tsizeof( Tchar ), nmemb, ofile -> GetFileStream() );
00403 if ( ss != nmemb ) {
00404 perror( head.c_str() );
00405 } else {
00406 datasize += ss * Tsizeof( Tchar );
00407 }
00408 }
00409
00410
00411
00412 ss = fwrite( &theElementType, Tsizeof( Telement_t ), nmemb, ofile -> GetFileStream() );
00413 if ( ss != nmemb ) {
00414 perror( head.c_str() );
00415 } else {
00416 datasize += ss * Tsizeof( Telement_t );
00417 }
00418
00419
00420
00421 ss = fwrite( &theNumberOfPrimitives, Tsizeof( Tint ), nmemb, ofile -> GetFileStream() );
00422 if ( ss != nmemb ) {
00423 perror( head.c_str() );
00424 } else {
00425 datasize += Tsizeof( Tint );
00426 }
00427
00428
00429 Tstring strbuf;
00430 switch ( theElementType ) {
00431
00432 case tTypeInt:
00433 Tint ii;
00434 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00435 ii = ( (Tint*)theData )[ i ];
00436 ss = fwrite( &ii, Tsizeof( Tint ), nmemb, ofile -> GetFileStream() );
00437 if ( ss != nmemb )
00438 perror( head.c_str() );
00439 else
00440 datasize += ss * Tsizeof( Tint );
00441 }
00442 break;
00443
00444
00445 case tTypeUnsignedInt:
00446 TUint ui;
00447 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00448 ui = ( (TUint*)theData )[ i ];
00449 ss = fwrite( &ui, Tsizeof( TUint ), nmemb, ofile -> GetFileStream() );
00450 if ( ss != nmemb )
00451 perror( head.c_str() );
00452 else
00453 datasize += ss * Tsizeof( TUint );
00454 }
00455 break;
00456
00457
00458 case tTypeUnsignedShort:
00459 case tTypeWord:
00460 TUshort us;
00461 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00462 us = ( (TUshort*)theData )[ i ];
00463 ss = fwrite( &us, Tsizeof( TUshort ), nmemb, ofile -> GetFileStream() );
00464 if ( ss != nmemb )
00465 perror( head.c_str() );
00466 else
00467 datasize += ss * Tsizeof( TUshort );
00468 }
00469 break;
00470
00471
00472 case tTypeDouble:
00473 Tdouble dd;
00474 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00475 dd = ( (Tdouble*)theData )[ i ];
00476 ss = fwrite( &dd, Tsizeof( Tdouble ), nmemb, ofile -> GetFileStream() );
00477 if ( ss != nmemb )
00478 perror( head.c_str() );
00479 else
00480 datasize += ss * Tsizeof( Tdouble );
00481 }
00482 break;
00483
00484
00485 case tTypeFloat:
00486 Tfloat ff;
00487 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00488 ff = ( (Tfloat*)theData )[ i ];
00489 ss = fwrite( &ff, Tsizeof( Tfloat ), nmemb, ofile -> GetFileStream() );
00490 if ( ss != nmemb )
00491 perror( head.c_str() );
00492 else
00493 datasize += ss * Tsizeof( Tfloat );
00494 }
00495 break;
00496
00497
00498 case tTypeShort:
00499 Tshort ww;
00500 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00501 ww = ( (Tshort*)theData )[ i ];
00502 ss = fwrite( &ww, Tsizeof( Tshort ), nmemb, ofile -> GetFileStream() );
00503 if ( ss != nmemb )
00504 perror( head.c_str() );
00505 else
00506 datasize += ss * Tsizeof( Tshort );
00507 }
00508 break;
00509
00510
00511 case tTypeLong:
00512 Tlong ll;
00513 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00514 ll = ( (Tlong*)theData )[ i ];
00515 ss = fwrite( &ll, Tsizeof( Tlong ), nmemb, ofile -> GetFileStream() );
00516 if ( ss != nmemb )
00517 perror( head.c_str() );
00518 else
00519 datasize += ss * Tsizeof( Tlong );
00520 }
00521 break;
00522
00523
00524 case tTypeUnsignedLong:
00525 TUlong ul;
00526 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00527 ul = ( (TUlong*)theData )[ i ];
00528 ss = fwrite( &ul, Tsizeof( TUlong ), nmemb, ofile -> GetFileStream() );
00529 if ( ss != nmemb ) {
00530 perror( head.c_str() );
00531 } else {
00532 datasize += ss * Tsizeof( TUlong );
00533 }
00534 }
00535 break;
00536
00537
00538 case tTypeString:
00539 Tchar cc;
00540 Tsize_t nchar;
00541
00542 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00543 strbuf = ( (Tstring*)theData )[ i ];
00544
00545 nchar = strbuf.size() + 1;
00546 ss = fwrite( &nchar, Tsizeof( Tsize_t ), nmemb, ofile -> GetFileStream() );
00547 if ( ss != nmemb ) {
00548 perror( head.c_str() );
00549 } else {
00550 datasize += ss * Tsizeof( Tsize_t );
00551 }
00552
00553
00554 for ( Tsize_t j = 0; j < nchar; j ++ ) {
00555 if ( j == ( nchar - 1 ) ) {
00556 cc = '\0';
00557 } else {
00558 cc = strbuf[ j ];
00559 }
00560 ss = fwrite( &cc, Tsizeof( Tchar ), nmemb, ofile -> GetFileStream() );
00561 if ( ss != nmemb ) {
00562 perror( head.c_str() );
00563 } else {
00564 datasize += ss * Tsizeof( Tchar );
00565 }
00566 }
00567 }
00568 break;
00569
00570
00571 case tTypeUnknown:
00572 case tTypeObject:
00573 default:
00574 break;
00575 }
00576
00577 return (Tint)datasize;
00578 }
00579
00580 Tint TDataElement::record( TOutputObjectSocket* osocket )
00581 {
00582 Tsize_t datasize = 0;
00583 static const Tstring head = "TDataElement::record";
00584
00585
00586
00587 Tint recsize = GetRecordSize();
00588 if ( send( osocket -> GetServerDescriptor(), &recsize, Tsizeof( Tint ), 0 ) != Tsizeof( Tint ) ) {
00589 perror( head.c_str() );
00590 } else {
00591 datasize += Tsizeof( Tint );
00592 }
00593
00594
00595
00596 if ( send( osocket -> GetServerDescriptor(), &theObjectType, Tsizeof( Tobject_t ), 0 ) != Tsizeof( Tobject_t ) ) {
00597 perror( head.c_str() );
00598 } else {
00599 datasize += Tsizeof( Tobject_t );
00600 }
00601
00602
00603
00604 Tchar charbuf;
00605 Tsize_t nchar = theID.size() + 1;
00606 if ( send( osocket -> GetServerDescriptor(), &nchar, Tsizeof( Tsize_t ), 0 ) != Tsizeof( Tsize_t ) ) {
00607 perror( head.c_str() );
00608 } else {
00609 datasize += Tsizeof( Tsize_t );
00610 }
00611 for ( Tsize_t i = 0; i < nchar; i ++ ) {
00612 if ( i == ( nchar - 1 ) ) {
00613 charbuf = '\0';
00614 } else {
00615 charbuf = theID[ i ];
00616 }
00617 if ( send( osocket -> GetServerDescriptor(), &charbuf, Tsizeof( Tchar ), 0 ) != Tsizeof( Tchar ) ) {
00618 perror( head.c_str() );
00619 } else {
00620 datasize += Tsizeof( Tchar );
00621 }
00622 }
00623
00624
00625
00626 if ( send( osocket -> GetServerDescriptor(), &theElementType, Tsizeof( Telement_t ), 0 ) != Tsizeof( Telement_t ) ) {
00627 perror( head.c_str() );
00628 } else {
00629 datasize += Tsizeof( Telement_t );
00630 }
00631
00632
00633
00634 if ( send( osocket -> GetServerDescriptor(), &theNumberOfPrimitives, Tsizeof( Tint ), 0 ) != Tsizeof( Tint ) ) {
00635 perror( head.c_str() );
00636 } else {
00637 datasize += Tsizeof( Tint );
00638 }
00639
00640
00641
00642
00643 Tstring strbuf;
00644 switch ( theElementType ) {
00645
00646
00647 case tTypeInt:
00648 Tint ii;
00649 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00650 ii = ( (Tint*)theData )[ i ];
00651 if ( send( osocket -> GetServerDescriptor(), &ii, Tsizeof( Tint ), 0 ) != Tsizeof( Tint ) ) {
00652 perror( head.c_str() );
00653 } else {
00654 datasize += Tsizeof( Tint );
00655 }
00656 }
00657 break;
00658
00659
00660 case tTypeUnsignedInt:
00661 TUint ui;
00662 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00663 ui = ( (TUint*)theData )[ i ];
00664 if ( send( osocket -> GetServerDescriptor(), &ui, Tsizeof( TUint ), 0 ) != Tsizeof( TUint ) ) {
00665 perror( head.c_str() );
00666 } else {
00667 datasize += Tsizeof( TUint );
00668 }
00669 }
00670 break;
00671
00672
00673
00674 case tTypeUnsignedShort:
00675 case tTypeWord:
00676 TUshort us;
00677 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00678 us = ( (TUshort*)theData )[ i ];
00679 if ( send( osocket -> GetServerDescriptor(), &us, Tsizeof( TUshort ), 0 ) != Tsizeof( TUshort ) ) {
00680 perror( head.c_str() );
00681 } else {
00682 datasize += Tsizeof( TUshort );
00683 }
00684 }
00685 break;
00686
00687
00688 case tTypeDouble:
00689 Tdouble dd;
00690 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00691 dd = ( (Tdouble*)theData )[ i ];
00692 if ( send( osocket -> GetServerDescriptor(), &dd, Tsizeof( Tdouble ), 0 ) != Tsizeof( Tdouble ) ) {
00693 perror( head.c_str() );
00694 } else {
00695 datasize += Tsizeof( Tdouble );
00696 }
00697 }
00698 break;
00699
00700
00701 case tTypeFloat:
00702 Tfloat ff;
00703 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00704 ff = ( (Tfloat*)theData )[ i ];
00705 if ( send( osocket -> GetServerDescriptor(), &ff, Tsizeof( Tfloat ), 0 ) != Tsizeof( Tfloat ) ) {
00706 perror( head.c_str() );
00707 } else {
00708 datasize += Tsizeof( Tfloat );
00709 }
00710 }
00711 break;
00712
00713
00714 case tTypeShort:
00715 Tshort ww;
00716 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00717 ww = ( (TUshort*)theData )[ i ];
00718 if ( send( osocket -> GetServerDescriptor(), &ww, Tsizeof( Tshort ), 0 ) != Tsizeof( Tshort ) ) {
00719 perror( head.c_str() );
00720 } else {
00721 datasize += Tsizeof( Tshort );
00722 }
00723 }
00724 break;
00725
00726
00727
00728 case tTypeLong:
00729 Tlong ll;
00730 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00731 ll = ( (Tlong*)theData )[ i ];
00732 if ( send( osocket -> GetServerDescriptor(), &ll, Tsizeof( Tlong ), 0 ) != Tsizeof( Tlong ) ) {
00733 perror( head.c_str() );
00734 } else {
00735 datasize += Tsizeof( Tlong );
00736 }
00737 }
00738 break;
00739
00740
00741 case tTypeUnsignedLong:
00742 TUlong ul;
00743 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00744 ul = ( (TUlong*)theData )[ i ];
00745 if ( send( osocket -> GetServerDescriptor(), &ul, Tsizeof( TUlong ), 0 ) != Tsizeof( TUlong ) ) {
00746 perror( head.c_str() );
00747 } else {
00748 datasize += Tsizeof( TUlong );
00749 }
00750 }
00751 break;
00752
00753
00754
00755 case tTypeString:
00756 Tchar cc;
00757 Tsize_t nchar;
00758
00759 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00760 strbuf = ( (Tstring*)theData )[ i ];
00761 nchar = strbuf.size() + 1;
00762 if ( send( osocket -> GetServerDescriptor(), &nchar, Tsizeof( Tsize_t ), 0 ) != Tsizeof( Tsize_t ) ) {
00763 perror( head.c_str() );
00764 } else {
00765 datasize += Tsizeof( Tsize_t );
00766 }
00767 for ( Tsize_t j = 0; j < nchar; j ++ ) {
00768 if ( j == ( nchar - 1 ) ) {
00769 cc = '\0';
00770 } else {
00771 cc = strbuf[ j ];
00772 }
00773 if ( send( osocket -> GetServerDescriptor(), &cc, Tsizeof( Tchar ), 0 ) != Tsizeof( Tchar ) ) {
00774 perror( head.c_str() );
00775 } else {
00776 datasize += Tsizeof( Tchar );
00777 }
00778 }
00779 }
00780 break;
00781
00782
00783
00784 case tTypeUnknown:
00785 case tTypeObject:
00786 default:
00787 break;
00788 }
00789
00790 return (Tint)datasize;
00791 }
00792
00793 Tint TDataElement::record( TOutputObjectSharedMemory* omemory )
00794 {
00795 Tsize_t datasize = 0;
00796 static const Tstring head = "TDataElement::record";
00797 Tvoid* ptr = omemory -> GetAddress();
00798
00799
00800
00801 *( (Tint*)ptr ) = GetRecordSize();
00802 datasize += Tsizeof( Tint );
00803 ( (Tint*)ptr ) ++;
00804
00805
00806
00807 *( (Tobject_t*)ptr ) = theObjectType;
00808 datasize += Tsizeof( Tobject_t );
00809 ( (Tobject_t*)ptr ) ++;
00810
00811
00812
00813 Tchar charbuf;
00814 Tsize_t nchar = theID.size() + 1;
00815 *( (Tsize_t*)ptr ) = nchar;
00816 datasize += Tsizeof( Tsize_t );
00817 ( (Tsize_t*)ptr ) ++;
00818 for ( Tsize_t i = 0; i < nchar; i ++ ) {
00819 if ( i == ( nchar - 1 ) ) {
00820 charbuf = '\0';
00821 } else {
00822 charbuf = theID[ i ];
00823 }
00824 *( (Tchar*)ptr ) = charbuf;
00825 datasize += Tsizeof( Tchar );
00826 ( (Tchar*)ptr ) ++;
00827 }
00828
00829
00830
00831 *( (Telement_t*)ptr ) = theElementType;
00832 datasize += Tsizeof( Telement_t );
00833 ( (Telement_t*)ptr ) ++;
00834
00835
00836
00837 *( (Tint*)ptr ) = theNumberOfPrimitives;
00838 datasize += Tsizeof( Tint );
00839 ( (Tint*)ptr ) ++;
00840
00841
00842 Tstring strbuf;
00843 switch ( theElementType ) {
00844
00845
00846 case tTypeInt:
00847 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00848 *( (Tint*)ptr ) = ( (Tint*)theData )[ i ];
00849 datasize += Tsizeof( Tint );
00850 ( (Tint*)ptr ) ++;
00851 }
00852 break;
00853
00854
00855 case tTypeUnsignedInt:
00856 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00857 *( (TUint*)ptr ) = ( (TUint*)theData )[ i ];
00858 datasize += Tsizeof( TUint );
00859 ( (TUint*)ptr ) ++;
00860 }
00861 break;
00862
00863
00864 case tTypeUnsignedShort:
00865 case tTypeWord:
00866 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00867 *( (TUshort*)ptr ) = ( (TUshort*)theData )[ i ];
00868 datasize += Tsizeof( TUshort );
00869 ( (TUshort*)ptr ) ++;
00870 }
00871 break;
00872
00873
00874 case tTypeDouble:
00875 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00876 *( (Tdouble*)ptr ) = ( (Tdouble*)theData )[ i ];
00877 datasize += Tsizeof( Tdouble );
00878 ( (Tdouble*)ptr ) ++;
00879 }
00880 break;
00881
00882
00883 case tTypeFloat:
00884 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00885 *( (Tfloat*)ptr ) = ( (Tfloat*)theData )[ i ];
00886 datasize += Tsizeof( Tfloat );
00887 ( (Tdouble*)ptr ) ++;
00888 }
00889 break;
00890
00891
00892 case tTypeShort:
00893 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00894 *( (Tshort*)ptr ) = ( (Tshort*)theData )[ i ];
00895 datasize += Tsizeof( Tshort );
00896 ( (Tshort*)ptr ) ++;
00897 }
00898 break;
00899
00900
00901 case tTypeLong:
00902 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00903 *( (Tlong*)ptr ) = ( (Tlong*)theData )[ i ];
00904 datasize += Tsizeof( Tlong );
00905 ( (Tlong*)ptr ) ++;
00906 }
00907 break;
00908
00909
00910 case tTypeUnsignedLong:
00911 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00912 *( (TUlong*)ptr ) = ( (TUlong*)theData )[ i ];
00913 datasize += Tsizeof( TUlong );
00914 ( (TUlong*)ptr ) ++;
00915 }
00916 break;
00917
00918
00919
00920 case tTypeString:
00921 Tchar cc;
00922 Tsize_t nchar;
00923
00924 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
00925 strbuf = ( (Tstring*)theData )[ i ];
00926 nchar = strbuf.size() + 1;
00927
00928
00929
00930 *( (Tsize_t*)ptr ) = nchar;
00931 datasize += Tsizeof( Tsize_t );
00932 ( (Tsize_t*)ptr ) ++;
00933
00934 for ( Tsize_t j = 0; j < nchar; j ++ ) {
00935 if ( j == ( nchar - 1 ) )
00936 cc = '\0';
00937 else
00938 cc = strbuf[ j ];
00939
00940
00941 *( (Tchar*)ptr ) = cc;
00942 datasize += Tsizeof( Tchar );
00943 ( (Tchar*)ptr ) ++;
00944 }
00945 }
00946 break;
00947
00948
00949 case tTypeUnknown:
00950 case tTypeObject:
00951 default:
00952 break;
00953 }
00954
00955 omemory -> SetAddress( ptr );
00956
00957 return (Tint)datasize;
00958 }
00959
00960 Tostream& operator<<( Tostream& tos, const TDataElement& right )
00961 {
00962
00963 tos << "Data Element(" << right.theObjectType << "), "
00964 << "ID: " << right.theID
00965 << ", Type: " << right.theElementType;
00966
00967 switch ( right.theElementType ) {
00968
00969
00970 case tTypeInt:
00971 tos << Tslash << "Tint(" << Tsizeof( Tint ) << "b), Data("
00972 << right.theNumberOfPrimitives << "): ";
00973 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
00974 tos << ( (Tint*)(right.theData) )[ i ];
00975 if ( i != right.theNumberOfPrimitives - 1 ) {
00976 tos << ", ";
00977 }
00978 }
00979 break;
00980
00981
00982 case tTypeUnsignedInt:
00983 tos << Tslash << "TUint(" << Tsizeof( TUint ) << "b), Data("
00984 << right.theNumberOfPrimitives << "): ";
00985 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
00986 tos << ( (TUint*)(right.theData) )[ i ];
00987 if ( i != right.theNumberOfPrimitives - 1 ) {
00988 tos << ", ";
00989 }
00990 }
00991 break;
00992
00993
00994
00995 case tTypeWord:
00996 case tTypeUnsignedShort:
00997 tos << Tslash << "TUshort(" << Tsizeof( TUshort ) << "b), Data("
00998 << right.theNumberOfPrimitives << "): ";
00999 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
01000 tos << ( (TUshort*)(right.theData) )[ i ];
01001 if ( i != right.theNumberOfPrimitives - 1 ) {
01002 tos << ", ";
01003 }
01004 }
01005 break;
01006
01007
01008
01009 case tTypeDouble:
01010 tos << Tslash << "Tdouble(" << Tsizeof( Tdouble ) << "b), Data("
01011 << right.theNumberOfPrimitives << "): ";
01012 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
01013 tos << ( (Tdouble*)(right.theData) )[ i ];
01014 if ( i != right.theNumberOfPrimitives - 1 ) {
01015 tos << ", ";
01016 }
01017 }
01018 break;
01019
01020
01021
01022 case tTypeFloat:
01023 tos << Tslash << "Tfloat(" << Tsizeof( Tfloat ) << "b), Data("
01024 << right.theNumberOfPrimitives << "): ";
01025 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
01026 tos << ( (Tfloat*)(right.theData) )[ i ];
01027 if ( i != right.theNumberOfPrimitives - 1 )
01028 tos << ", ";
01029 }
01030 break;
01031
01032
01033
01034 case tTypeShort:
01035 tos << Tslash << "Tshort(" << Tsizeof( Tshort ) << "b), Data("
01036 << right.theNumberOfPrimitives << "): ";
01037 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
01038 tos << ( (Tshort*)(right.theData) )[ i ];
01039 if ( i != right.theNumberOfPrimitives - 1 ) {
01040 tos << ", ";
01041 }
01042 }
01043 break;
01044
01045
01046
01047 case tTypeLong:
01048 tos << Tslash << "Tlong(" << Tsizeof( Tlong ) << "b), Data("
01049 << right.theNumberOfPrimitives << "): ";
01050 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
01051 tos << ( (Tlong*)(right.theData) )[ i ];
01052 if ( i != right.theNumberOfPrimitives - 1 ) {
01053 tos << ", ";
01054 }
01055 }
01056 break;
01057
01058
01059 case tTypeUnsignedLong:
01060 tos << Tslash << "TUlong(" << Tsizeof( TUlong ) << "b), Data("
01061 << right.theNumberOfPrimitives << "): ";
01062 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
01063 tos << ( (TUlong*)(right.theData) )[ i ];
01064 if ( i != right.theNumberOfPrimitives - 1 )
01065 tos << ", ";
01066 }
01067 break;
01068
01069
01070
01071 case tTypeString:
01072 tos << Tslash << "Tstring, Data("
01073 << right.theNumberOfPrimitives << "): ";
01074 for ( Tint i = 0; i < right.theNumberOfPrimitives; i ++ ) {
01075 tos << ( (Tstring*)(right.theData) )[ i ];
01076 if ( i != right.theNumberOfPrimitives - 1 ) {
01077 tos << ", ";
01078 }
01079 }
01080 break;
01081
01082
01083 case tTypeUnknown:
01084 case tTypeObject:
01085 default:
01086 tos << Tslash << "Unknown, Data: unknown(or undefined) data.";
01087 break;
01088 }
01089
01090 return tos;
01091 }
01092
01093 Tvoid TDataElement::freeDataSpace()
01094 {
01095 if ( theData != 0 ) {
01096 switch ( theElementType ) {
01097
01098 case tTypeInt:
01099 delete [] (Tint*)theData;
01100 break;
01101
01102 case tTypeUnsignedInt:
01103 delete [] (TUint*)theData;
01104 break;
01105
01106 case tTypeWord:
01107 case tTypeUnsignedShort:
01108 delete [] (TUshort*)theData;
01109 break;
01110
01111 case tTypeDouble:
01112 delete [] (Tdouble*)theData;
01113 break;
01114
01115 case tTypeFloat:
01116 delete [] (Tfloat*)theData;
01117 break;
01118
01119 case tTypeShort:
01120 delete [] (Tshort*)theData;
01121 break;
01122
01123 case tTypeLong:
01124 delete [] (Tlong*)theData;
01125 break;
01126
01127 case tTypeUnsignedLong:
01128 delete [] (TUlong*)theData;
01129 break;
01130
01131 case tTypeString:
01132 delete [] (Tstring*)theData;
01133 break;
01134
01135 case tTypeUnknown:
01136 case tTypeObject:
01137 default:
01138 break;
01139 }
01140 }
01141 theData = 0;
01142 theNumberOfPrimitives = 0;
01143 return;
01144 }
01145
01146 Tvoid TDataElement::allocateDataSpace( Tvoid* data )
01147 {
01148 if ( data == 0 ) {
01149 return;
01150 }
01151
01152 switch ( theElementType ) {
01153
01154 case tTypeInt:
01155 theData = new Tint[ theNumberOfPrimitives ];
01156 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01157 ( (Tint*)(theData) )[ i ] = *( (Tint*)data );
01158 ( (Tint*)data ) ++;
01159 }
01160 break;
01161
01162
01163 case tTypeUnsignedInt:
01164 theData = new TUint[ theNumberOfPrimitives ];
01165 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01166 ( (TUint*)(theData) )[ i ] = *( (TUint*)data );
01167 ( (TUint*)data ) ++;
01168 }
01169 break;
01170
01171 case tTypeWord:
01172 case tTypeUnsignedShort:
01173 theData = new TUshort[ theNumberOfPrimitives ];
01174 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01175 ( (TUshort*)(theData) )[ i ] = *( (TUshort*)data );
01176 ( (TUshort*)data ) ++;
01177 }
01178 break;
01179
01180 case tTypeDouble:
01181 theData = new Tdouble[ theNumberOfPrimitives ];
01182 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01183 ( (Tdouble*)(theData) )[ i ] = *( (Tdouble*)data );
01184 ( (Tdouble*)data ) ++;
01185 }
01186 break;
01187
01188 case tTypeFloat:
01189 theData = new Tfloat[ theNumberOfPrimitives ];
01190 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01191 ( (Tfloat*)(theData) )[ i ] = *( (Tfloat*)data );
01192 ( (Tfloat*)data ) ++;
01193 }
01194 break;
01195
01196 case tTypeShort:
01197 theData = new Tshort[ theNumberOfPrimitives ];
01198 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01199 ( (Tshort*)(theData) )[ i ] = *( (Tshort*)data );
01200 ( (Tshort*)data ) ++;
01201 }
01202 break;
01203
01204 case tTypeLong:
01205 theData = new Tlong[ theNumberOfPrimitives ];
01206 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01207 ( (Tlong*)(theData) )[ i ] = *( (Tlong*)data );
01208 ( (Tlong*)data ) ++;
01209 }
01210 break;
01211
01212 case tTypeUnsignedLong:
01213 theData = new TUlong[ theNumberOfPrimitives ];
01214 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01215 ( (TUlong*)(theData) )[ i ] = *( (TUlong*)data );
01216 ( (TUlong*)data ) ++;
01217 }
01218 break;
01219
01220 case tTypeString:
01221 theData = new Tstring[ theNumberOfPrimitives ];
01222 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01223 ( (Tstring*)(theData) )[ i ] = *( (Tstring*)data );
01224 ( (Tstring*)data ) ++;
01225 }
01226 break;
01227
01228 case tTypeUnknown:
01229 case tTypeObject:
01230 default:
01231 break;
01232 }
01233 return;
01234 }
01235
01236 Tvoid TDataElement::Clear()
01237 {
01238 freeDataSpace();
01239 theID = TunknownID;
01240 theElementType = tTypeUnknown;
01241 return;
01242 }
01243
01244 Tint TDataElement::Serialize( const Tvoid* buffer )
01245 {
01246 Tvoid* p = const_cast<Tvoid*>(buffer);
01247 Tsize_t datasize = 0;
01248
01249
01250 *( (Tint*)p ) = GetRecordSize();
01251 ( (Tint*)p ) ++;
01252 datasize += Tsizeof( Tint );
01253
01254
01255
01256 *( (Tobject_t*)p ) = theObjectType;
01257 ( (Tobject_t*)p ) ++;
01258 datasize += Tsizeof( Tobject_t );
01259
01260
01261
01262 Tchar charbuf;
01263 Tsize_t nchar = theID.size() + 1;
01264 *( (Tsize_t*)p ) = nchar;
01265 ( (Tsize_t*)p ) ++;
01266 datasize += Tsizeof( Tsize_t );
01267 for ( Tsize_t i = 0; i < nchar; i ++ ) {
01268 if ( i == ( nchar - 1 ) ) {
01269 charbuf = '\0';
01270 } else {
01271 charbuf = theID[ i ];
01272 }
01273 *( (Tchar*)p ) = charbuf;
01274 ( (Tchar*)p ) ++;
01275 datasize += Tsizeof( Tchar );
01276 }
01277
01278
01279
01280 *( (Telement_t*)p ) = theElementType;
01281 ( (Telement_t*)p ) ++;
01282 datasize += Tsizeof( Telement_t );
01283
01284
01285
01286 *( (Tint*)p ) = theNumberOfPrimitives;
01287 ( (Tint*)p ) ++;
01288 datasize += Tsizeof( Tint );
01289
01290
01291
01292 Tstring strbuf;
01293 switch ( theElementType ) {
01294
01295 case tTypeInt:
01296 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01297 *( (Tint*)p ) = ( (Tint*)theData )[ i ];
01298 ( (Tint*)p ) ++;
01299 datasize += Tsizeof( Tint );
01300 }
01301 break;
01302
01303
01304 case tTypeUnsignedInt:
01305 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01306 *( (TUint*)p ) = ( (TUint*)theData )[ i ];
01307 ( (TUint*)p ) ++;
01308 datasize += Tsizeof( TUint );
01309 }
01310 break;
01311
01312
01313 case tTypeUnsignedShort:
01314 case tTypeWord:
01315 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01316 *( (TUshort*)p ) = ( (TUshort*)theData )[ i ];
01317 ( (TUshort*)p ) ++;
01318 datasize += Tsizeof( TUshort );
01319 }
01320 break;
01321
01322
01323 case tTypeDouble:
01324 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01325 *( (Tdouble*)p ) = ( (Tdouble*)theData )[ i ];
01326 ( (Tdouble*)p ) ++;
01327 datasize += Tsizeof( Tdouble );
01328 }
01329 break;
01330
01331
01332 case tTypeFloat:
01333 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01334 *( (Tfloat*)p ) = ( (Tfloat*)theData )[ i ];
01335 ( (Tfloat*)p ) ++;
01336 datasize += Tsizeof( Tfloat );
01337 }
01338 break;
01339
01340
01341 case tTypeShort:
01342 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01343 *( (Tshort*)p ) = ( (Tshort*)theData )[ i ];
01344 ( (Tshort*)p ) ++;
01345 datasize += Tsizeof( Tshort );
01346 }
01347 break;
01348
01349
01350 case tTypeLong:
01351 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01352 *( (Tlong*)p ) = ( (Tlong*)theData )[ i ];
01353 ( (Tlong*)p ) ++;
01354 datasize += Tsizeof( Tlong );
01355 }
01356 break;
01357
01358
01359 case tTypeUnsignedLong:
01360 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01361 *( (TUlong*)p ) = ( (TUlong*)theData )[ i ];
01362 ( (TUlong*)p ) ++;
01363 datasize += Tsizeof( TUlong );
01364 }
01365 break;
01366
01367
01368 case tTypeString:
01369 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01370 strbuf = ( (Tstring*)theData )[ i ];
01371 nchar = strbuf.size() + 1;
01372 *( (Tsize_t*)p ) = nchar;
01373 ( (Tsize_t*)p ) ++;
01374 datasize += Tsizeof( Tsize_t );
01375
01376 for ( Tsize_t j = 0; j < nchar; j ++ ) {
01377 if ( j == ( nchar - 1 ) ) {
01378 charbuf = '\0';
01379 } else {
01380 charbuf = strbuf[ j ];
01381 }
01382 *( (Tchar*)p ) = charbuf;
01383 ( (Tchar*)p ) ++;
01384 datasize += Tsizeof( Tchar );
01385 }
01386 }
01387 break;
01388
01389 case tTypeUnknown:
01390 case tTypeObject:
01391 default:
01392 break;
01393 }
01394
01395 return (Tint)datasize;
01396 }
01397
01398 Tint TDataElement::Deserialize( const Tvoid* buffer )
01399 {
01400 Tvoid* p = const_cast<Tvoid*>(buffer);
01401 Tsize_t datasize = 0;
01402
01403
01404 ( (Tint*)p ) ++;
01405 datasize += Tsizeof( Tint );
01406
01407
01408
01409 theObjectType = *( (Tobject_t*)p );
01410 ( (Tobject_t*)p ) ++;
01411 datasize += Tsizeof( Tobject_t );
01412
01413
01414
01415
01416 Tsize_t nchar = *( (Tsize_t*)p );
01417 ( (Tsize_t*)p ) ++;
01418 datasize += Tsizeof( Tsize_t );
01419
01420 Tchar* cc = new Tchar[ nchar ];
01421 for ( Tsize_t i = 0; i < nchar; i ++ ) {
01422 cc[i] = *( (Tchar*)p );
01423 datasize += Tsizeof( Tchar );
01424 ( (Tchar*)p ) ++;
01425 }
01426 theID = cc;
01427 delete [] cc;
01428
01429
01430
01431 theElementType = *( (Telement_t*)p );
01432 ( (Telement_t*)p ) ++;
01433 datasize += Tsizeof( Telement_t );
01434
01435
01436
01437 theNumberOfPrimitives = *( (Tint*)p );
01438 ( (Tint*)p ) ++;
01439 datasize += Tsizeof( Tint );
01440
01441
01442 Tvoid freeDataSpace();
01443 switch ( theElementType ) {
01444
01445 case tTypeInt:
01446 theData = new Tint[ theNumberOfPrimitives ];
01447 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01448 ( (Tint*)(theData) )[ i ] = *( (Tint*)p );
01449 ( (Tint*)p ) ++;
01450 datasize += Tsizeof( Tint );
01451 }
01452 break;
01453
01454 case tTypeUnsignedInt:
01455 theData = new TUint[ theNumberOfPrimitives ];
01456 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01457 ( (TUint*)(theData) )[ i ] = *( (TUint*)p );
01458 ( (TUint*)p ) ++;
01459 datasize += Tsizeof( TUint );
01460 }
01461 break;
01462
01463 case tTypeWord:
01464 case tTypeUnsignedShort:
01465 theData = new TUshort[ theNumberOfPrimitives ];
01466 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01467 ( (TUshort*)(theData) )[ i ] = *( (TUshort*)p );
01468 ( (TUshort*)p ) ++;
01469 datasize += Tsizeof( TUshort );
01470 }
01471 break;
01472
01473 case tTypeDouble:
01474 theData = new Tdouble[ theNumberOfPrimitives ];
01475 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01476 ( (Tdouble*)(theData) )[ i ] = *( (Tdouble*)p );
01477 ( (Tdouble*)p ) ++;
01478 datasize += Tsizeof( Tdouble );
01479 }
01480 break;
01481
01482 case tTypeFloat:
01483 theData = new Tfloat[ theNumberOfPrimitives ];
01484 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01485 ( (Tfloat*)(theData) )[ i ] = *( (Tfloat*)p );
01486 ( (Tfloat*)p ) ++;
01487 datasize += Tsizeof( Tfloat );
01488 }
01489 break;
01490
01491 case tTypeShort:
01492 theData = new Tshort[ theNumberOfPrimitives ];
01493 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01494 ( (Tshort*)(theData) )[ i ] = *( (Tshort*)p );
01495 ( (Tshort*)p ) ++;
01496 datasize += Tsizeof( Tshort );
01497 }
01498 break;
01499
01500 case tTypeLong:
01501 theData = new Tlong[ theNumberOfPrimitives ];
01502 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01503 ( (Tlong*)(theData) )[ i ] = *( (Tlong*)p );
01504 ( (Tlong*)p ) ++;
01505 datasize += Tsizeof( Tlong );
01506 }
01507 break;
01508
01509 case tTypeUnsignedLong:
01510 theData = new TUlong[ theNumberOfPrimitives ];
01511 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01512 ( (TUlong*)(theData) )[ i ] = *( (TUlong*)p );
01513 ( (TUlong*)p ) ++;
01514 datasize += Tsizeof( TUlong );
01515 }
01516 break;
01517
01518
01519 case tTypeString:
01520 theData = new Tstring[ theNumberOfPrimitives ];
01521 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01522 Tsize_t nchar = *( (Tsize_t*)p );
01523 ( (Tsize_t*)p ) ++;
01524 datasize += Tsizeof( Tsize_t );
01525
01526 Tchar* cc = new Tchar[ nchar ];
01527 for ( Tsize_t j = 0; j < nchar; j ++ ) {
01528 cc[j] = *( (Tchar*)p );
01529 datasize += Tsizeof( Tchar );
01530 ( (Tchar*)p ) ++;
01531 }
01532 ((Tstring*)theData)[i] = cc;
01533 delete [] cc;
01534 }
01535 break;
01536
01537 case tTypeUnknown:
01538 case tTypeObject:
01539 default:
01540 break;
01541 }
01542
01543
01544 return datasize;
01545 }
01546
01547 Tint TDataElement::StorePrimitives( Tint* buffer, Tint narray ) const
01548 {
01549 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
01550 Tint nfilled = 0;
01551
01552 switch ( theElementType ) {
01553 case tTypeInt:
01554 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01555 if ( narray != 0 && narray == i ) {
01556 Tcerr << error << Tendl;
01557 break;
01558 }
01559 buffer[ i ] = (Tint)( (Tint*)theData )[ i ];
01560 nfilled ++;
01561 }
01562 break;
01563
01564 case tTypeUnsignedInt:
01565 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01566 if ( narray != 0 && narray == i ) {
01567 Tcerr << error << Tendl;
01568 break;
01569 }
01570 buffer[ i ] = (Tint)( (TUint*)theData )[ i ];
01571 nfilled ++;
01572 }
01573 break;
01574
01575 case tTypeUnsignedShort:
01576 case tTypeWord:
01577 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01578 if ( narray != 0 && narray == i ) {
01579 Tcerr << error << Tendl;
01580 break;
01581 }
01582 buffer[ i ] = (Tint)( (TUshort*)theData )[ i ];
01583 nfilled ++;
01584 }
01585 break;
01586
01587 case tTypeDouble:
01588 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01589 if ( narray != 0 && narray == i ) {
01590 Tcerr << error << Tendl;
01591 break;
01592 }
01593 buffer[ i ] = (Tint)( (Tdouble*)theData )[ i ];
01594 nfilled ++;
01595 }
01596 break;
01597
01598 case tTypeFloat:
01599 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01600 if ( narray != 0 && narray == i ) {
01601 Tcerr << error << Tendl;
01602 break;
01603 }
01604 buffer[ i ] = (Tint)( (Tfloat*)theData )[ i ];
01605 nfilled ++;
01606 }
01607 break;
01608
01609 case tTypeShort:
01610 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01611 if ( narray != 0 && narray == i ) {
01612 Tcerr << error << Tendl;
01613 break;
01614 }
01615 buffer[ i ] = (Tint)( (Tshort*)theData )[ i ];
01616 nfilled ++;
01617 }
01618 break;
01619
01620 case tTypeLong:
01621 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01622 if ( narray != 0 && narray == i ) {
01623 Tcerr << error << Tendl;
01624 break;
01625 }
01626 buffer[ i ] = (Tint)( (Tlong*)theData )[ i ];
01627 nfilled ++;
01628 }
01629 break;
01630
01631 case tTypeUnsignedLong:
01632 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01633 if ( narray != 0 && narray == i ) {
01634 Tcerr << error << Tendl;
01635 break;
01636 }
01637 buffer[ i ] = (Tint)( (TUlong*)theData )[ i ];
01638 nfilled ++;
01639 }
01640 break;
01641
01642 case tTypeString:
01643 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01644 if ( narray != 0 && narray == i ) {
01645 Tcerr << error << Tendl;
01646 break;
01647 }
01648 buffer[ i ] = (Tint)strtol( (((Tstring*)theData )[ i ]).c_str(), 0, 0 );
01649 nfilled ++;
01650 }
01651 break;
01652
01653 case tTypeUnknown:
01654 case tTypeObject:
01655 default:
01656 static const Tstring head = "TDataElement::StorePrimitives: ";
01657 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
01658 Tcerr << head << "nothing to do." << Tendl;
01659 break;
01660 }
01661
01662 return nfilled;
01663 }
01664
01665 Tint TDataElement::StorePrimitives( Tdouble* buffer, Tint narray ) const
01666 {
01667 Tint nfilled = 0;
01668 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
01669
01670 switch ( theElementType ) {
01671 case tTypeInt:
01672 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01673 if ( narray != 0 && narray == i ) {
01674 Tcerr << error << Tendl;
01675 break;
01676 }
01677 buffer[ i ] = (Tdouble)( (Tint*)theData )[ i ];
01678 nfilled ++;
01679 }
01680 break;
01681
01682 case tTypeUnsignedInt:
01683 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01684 if ( narray != 0 && narray == i ) {
01685 Tcerr << error << Tendl;
01686 break;
01687 }
01688 buffer[ i ] = (Tdouble)( (TUint*)theData )[ i ];
01689 nfilled ++;
01690 }
01691 break;
01692
01693 case tTypeUnsignedShort:
01694 case tTypeWord:
01695 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01696 if ( narray != 0 && narray == i ) {
01697 Tcerr << error << Tendl;
01698 break;
01699 }
01700 buffer[ i ] = (Tdouble)( (TUshort*)theData )[ i ];
01701 nfilled ++;
01702 }
01703 break;
01704
01705 case tTypeDouble:
01706 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01707 if ( narray != 0 && narray == i ) {
01708 Tcerr << error << Tendl;
01709 break;
01710 }
01711 buffer[ i ] = (Tdouble)( (Tdouble*)theData )[ i ];
01712 nfilled ++;
01713 }
01714 break;
01715
01716 case tTypeFloat:
01717 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01718 if ( narray != 0 && narray == i ) {
01719 Tcerr << error << Tendl;
01720 break;
01721 }
01722 buffer[ i ] = (Tdouble)( (Tfloat*)theData )[ i ];
01723 nfilled ++;
01724 }
01725 break;
01726
01727 case tTypeShort:
01728 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01729 if ( narray != 0 && narray == i ) {
01730 Tcerr << error << Tendl;
01731 break;
01732 }
01733 buffer[ i ] = (Tdouble)( (Tshort*)theData )[ i ];
01734 nfilled ++;
01735 }
01736 break;
01737
01738 case tTypeLong:
01739 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01740 if ( narray != 0 && narray == i ) {
01741 Tcerr << error << Tendl;
01742 break;
01743 }
01744 buffer[ i ] = (Tdouble)( (Tlong*)theData )[ i ];
01745 nfilled ++;
01746 }
01747 break;
01748
01749 case tTypeUnsignedLong:
01750 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01751 if ( narray != 0 && narray == i ) {
01752 Tcerr << error << Tendl;
01753 break;
01754 }
01755 buffer[ i ] = (Tdouble)( (TUlong*)theData )[ i ];
01756 nfilled ++;
01757 }
01758 break;
01759
01760 case tTypeString:
01761 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01762 if ( narray != 0 && narray == i ) {
01763 Tcerr << error << Tendl;
01764 break;
01765 }
01766 buffer[ i ] = (Tdouble)strtod( (((Tstring*)theData )[ i ]).c_str(), 0 );
01767 nfilled ++;
01768 }
01769 break;
01770
01771 case tTypeUnknown:
01772 case tTypeObject:
01773 default:
01774 static const Tstring head = "TDataElement::StorePrimitives: ";
01775 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
01776 Tcerr << head << "nothing to do." << Tendl;
01777 break;
01778 }
01779
01780 return nfilled;
01781 }
01782
01783 Tint TDataElement::StorePrimitives( Tfloat* buffer, Tint narray ) const
01784 {
01785 Tint nfilled = 0;
01786 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
01787
01788 switch ( theElementType ) {
01789 case tTypeInt:
01790 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01791 if ( narray != 0 && narray == i ) {
01792 Tcerr << error << Tendl;
01793 break;
01794 }
01795 buffer[ i ] = (Tfloat)( (Tint*)theData )[ i ];
01796 nfilled ++;
01797 }
01798 break;
01799
01800 case tTypeUnsignedInt:
01801 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01802 if ( narray != 0 && narray == i ) {
01803 Tcerr << error << Tendl;
01804 break;
01805 }
01806 buffer[ i ] = (Tfloat)( (TUint*)theData )[ i ];
01807 nfilled ++;
01808 }
01809 break;
01810
01811 case tTypeUnsignedShort:
01812 case tTypeWord:
01813 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01814 if ( narray != 0 && narray == i ) {
01815 Tcerr << error << Tendl;
01816 break;
01817 }
01818 buffer[ i ] = (Tfloat)( (TUshort*)theData )[ i ];
01819 nfilled ++;
01820 }
01821 break;
01822
01823 case tTypeDouble:
01824 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01825 if ( narray != 0 && narray == i ) {
01826 Tcerr << error << Tendl;
01827 break;
01828 }
01829 buffer[ i ] = (Tfloat)( (Tdouble*)theData )[ i ];
01830 nfilled ++;
01831 }
01832 break;
01833
01834 case tTypeFloat:
01835 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01836 if ( narray != 0 && narray == i ) {
01837 Tcerr << error << Tendl;
01838 break;
01839 }
01840 buffer[ i ] = (Tfloat)( (Tfloat*)theData )[ i ];
01841 nfilled ++;
01842 }
01843 break;
01844
01845 case tTypeShort:
01846 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01847 if ( narray != 0 && narray == i ) {
01848 Tcerr << error << Tendl;
01849 break;
01850 }
01851 buffer[ i ] = (Tfloat)( (Tshort*)theData )[ i ];
01852 nfilled ++;
01853 }
01854 break;
01855
01856 case tTypeLong:
01857 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01858 if ( narray != 0 && narray == i ) {
01859 Tcerr << error << Tendl;
01860 break;
01861 }
01862 buffer[ i ] = (Tfloat)( (Tlong*)theData )[ i ];
01863 nfilled ++;
01864 }
01865 break;
01866
01867 case tTypeUnsignedLong:
01868 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01869 if ( narray != 0 && narray == i ) {
01870 Tcerr << error << Tendl;
01871 break;
01872 }
01873 buffer[ i ] = (Tfloat)( (TUlong*)theData )[ i ];
01874 nfilled ++;
01875 }
01876 break;
01877
01878 case tTypeString:
01879 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01880 if ( narray != 0 && narray == i ) {
01881 Tcerr << error << Tendl;
01882 break;
01883 }
01884 buffer[ i ] = (Tfloat)strtof( (((Tstring*)theData )[ i ]).c_str(), 0 );
01885 nfilled ++;
01886 }
01887 break;
01888
01889 case tTypeUnknown:
01890 case tTypeObject:
01891 default:
01892 static const Tstring head = "TDataElement::StorePrimitives: ";
01893 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
01894 Tcerr << head << "nothing to do." << Tendl;
01895 break;
01896 }
01897
01898 return nfilled;
01899 }
01900
01901 Tint TDataElement::StorePrimitives( TUshort* buffer, Tint narray ) const
01902 {
01903 Tint nfilled = 0;
01904 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
01905
01906 switch ( theElementType ) {
01907 case tTypeInt:
01908 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01909 if ( narray != 0 && narray == i ) {
01910 Tcerr << error << Tendl;
01911 break;
01912 }
01913 buffer[ i ] = (TUshort)( (Tint*)theData )[ i ];
01914 nfilled ++;
01915 }
01916 break;
01917
01918 case tTypeUnsignedInt:
01919 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01920 if ( narray != 0 && narray == i ) {
01921 Tcerr << error << Tendl;
01922 break;
01923 }
01924 buffer[ i ] = (TUshort)( (TUint*)theData )[ i ];
01925 nfilled ++;
01926 }
01927 break;
01928
01929 case tTypeUnsignedShort:
01930 case tTypeWord:
01931 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01932 if ( narray != 0 && narray == i ) {
01933 Tcerr << error << Tendl;
01934 break;
01935 }
01936 buffer[ i ] = (TUshort)( (TUshort*)theData )[ i ];
01937 nfilled ++;
01938 }
01939 break;
01940
01941 case tTypeDouble:
01942 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01943 if ( narray != 0 && narray == i ) {
01944 Tcerr << error << Tendl;
01945 break;
01946 }
01947 buffer[ i ] = (TUshort)( (Tdouble*)theData )[ i ];
01948 nfilled ++;
01949 }
01950 break;
01951
01952 case tTypeFloat:
01953 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01954 if ( narray != 0 && narray == i ) {
01955 Tcerr << error << Tendl;
01956 break;
01957 }
01958 buffer[ i ] = (TUshort)( (Tfloat*)theData )[ i ];
01959 nfilled ++;
01960 }
01961 break;
01962
01963 case tTypeShort:
01964 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01965 if ( narray != 0 && narray == i ) {
01966 Tcerr << error << Tendl;
01967 break;
01968 }
01969 buffer[ i ] = (TUshort)( (Tshort*)theData )[ i ];
01970 nfilled ++;
01971 }
01972 break;
01973
01974 case tTypeLong:
01975 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01976 if ( narray != 0 && narray == i ) {
01977 Tcerr << error << Tendl;
01978 break;
01979 }
01980 buffer[ i ] = (TUshort)( (Tlong*)theData )[ i ];
01981 nfilled ++;
01982 }
01983 break;
01984
01985 case tTypeUnsignedLong:
01986 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01987 if ( narray != 0 && narray == i ) {
01988 Tcerr << error << Tendl;
01989 break;
01990 }
01991 buffer[ i ] = (TUshort)( (TUlong*)theData )[ i ];
01992 nfilled ++;
01993 }
01994 break;
01995
01996 case tTypeString:
01997 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
01998 if ( narray != 0 && narray == i ) {
01999 Tcerr << error << Tendl;
02000 break;
02001 }
02002 buffer[ i ] = (TUshort)strtoul( (((Tstring*)theData )[ i ]).c_str(), 0, 0 );
02003 nfilled ++;
02004 }
02005 break;
02006
02007 case tTypeUnknown:
02008 case tTypeObject:
02009 default:
02010 static const Tstring head = "TDataElement::StorePrimitives: ";
02011 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
02012 Tcerr << head << "nothing to do." << Tendl;
02013 break;
02014 }
02015
02016 return nfilled;
02017 }
02018
02019 Tint TDataElement::StorePrimitives( Tshort* buffer, Tint narray ) const
02020 {
02021 Tint nfilled = 0;
02022 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
02023
02024 switch ( theElementType ) {
02025 case tTypeInt:
02026 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02027 if ( narray != 0 && narray == i ) {
02028 Tcerr << error << Tendl;
02029 break;
02030 }
02031 buffer[ i ] = (Tshort)( (Tint*)theData )[ i ];
02032 nfilled ++;
02033 }
02034 break;
02035
02036 case tTypeUnsignedInt:
02037 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02038 if ( narray != 0 && narray == i ) {
02039 Tcerr << error << Tendl;
02040 break;
02041 }
02042 buffer[ i ] = (Tshort)( (TUint*)theData )[ i ];
02043 nfilled ++;
02044 }
02045 break;
02046
02047 case tTypeUnsignedShort:
02048 case tTypeWord:
02049 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02050 if ( narray != 0 && narray == i ) {
02051 Tcerr << error << Tendl;
02052 break;
02053 }
02054 buffer[ i ] = (Tshort)( (TUshort*)theData )[ i ];
02055 nfilled ++;
02056 }
02057 break;
02058
02059 case tTypeDouble:
02060 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02061 if ( narray != 0 && narray == i ) {
02062 Tcerr << error << Tendl;
02063 break;
02064 }
02065 buffer[ i ] = (Tshort)( (Tdouble*)theData )[ i ];
02066 nfilled ++;
02067 }
02068 break;
02069
02070 case tTypeFloat:
02071 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02072 if ( narray != 0 && narray == i ) {
02073 Tcerr << error << Tendl;
02074 break;
02075 }
02076 buffer[ i ] = (Tshort)( (Tfloat*)theData )[ i ];
02077 nfilled ++;
02078 }
02079 break;
02080
02081 case tTypeShort:
02082 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02083 if ( narray != 0 && narray == i ) {
02084 Tcerr << error << Tendl;
02085 break;
02086 }
02087 buffer[ i ] = (Tshort)( (Tshort*)theData )[ i ];
02088 nfilled ++;
02089 }
02090 break;
02091
02092 case tTypeLong:
02093 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02094 if ( narray != 0 && narray == i ) {
02095 Tcerr << error << Tendl;
02096 break;
02097 }
02098 buffer[ i ] = (Tshort)( (Tlong*)theData )[ i ];
02099 nfilled ++;
02100 }
02101 break;
02102
02103 case tTypeUnsignedLong:
02104 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02105 if ( narray != 0 && narray == i ) {
02106 Tcerr << error << Tendl;
02107 break;
02108 }
02109 buffer[ i ] = (Tshort)( (TUlong*)theData )[ i ];
02110 nfilled ++;
02111 }
02112 break;
02113
02114 case tTypeString:
02115 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02116 if ( narray != 0 && narray == i ) {
02117 Tcerr << error << Tendl;
02118 break;
02119 }
02120 buffer[ i ] = (Tshort)strtol( (((Tstring*)theData )[ i ]).c_str(), 0, 0 );
02121 nfilled ++;
02122 }
02123 break;
02124
02125 case tTypeUnknown:
02126 case tTypeObject:
02127 default:
02128 static const Tstring head = "TDataElement::StorePrimitives: ";
02129 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
02130 Tcerr << head << "nothing to do." << Tendl;
02131 break;
02132 }
02133
02134 return nfilled;
02135 }
02136
02137 Tint TDataElement::StorePrimitives( Tlong* buffer, Tint narray ) const
02138 {
02139 Tint nfilled = 0;
02140 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
02141
02142 switch ( theElementType ) {
02143 case tTypeInt:
02144 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02145 if ( narray != 0 && narray == i ) {
02146 Tcerr << error << Tendl;
02147 break;
02148 }
02149 buffer[ i ] = (Tlong)( (Tint*)theData )[ i ];
02150 nfilled ++;
02151 }
02152 break;
02153
02154 case tTypeUnsignedInt:
02155 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02156 if ( narray != 0 && narray == i ) {
02157 Tcerr << error << Tendl;
02158 break;
02159 }
02160 buffer[ i ] = (Tlong)( (TUint*)theData )[ i ];
02161 nfilled ++;
02162 }
02163 break;
02164
02165 case tTypeUnsignedShort:
02166 case tTypeWord:
02167 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02168 if ( narray != 0 && narray == i ) {
02169 Tcerr << error << Tendl;
02170 break;
02171 }
02172 buffer[ i ] = (Tlong)( (TUshort*)theData )[ i ];
02173 nfilled ++;
02174 }
02175 break;
02176
02177 case tTypeDouble:
02178 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02179 if ( narray != 0 && narray == i ) {
02180 Tcerr << error << Tendl;
02181 break;
02182 }
02183 buffer[ i ] = (Tlong)( (Tdouble*)theData )[ i ];
02184 nfilled ++;
02185 }
02186 break;
02187
02188 case tTypeFloat:
02189 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02190 if ( narray != 0 && narray == i ) {
02191 Tcerr << error << Tendl;
02192 break;
02193 }
02194 buffer[ i ] = (Tlong)( (Tfloat*)theData )[ i ];
02195 nfilled ++;
02196 }
02197 break;
02198
02199 case tTypeShort:
02200 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02201 if ( narray != 0 && narray == i ) {
02202 Tcerr << error << Tendl;
02203 break;
02204 }
02205 buffer[ i ] = (Tlong)( (Tshort*)theData )[ i ];
02206 nfilled ++;
02207 }
02208 break;
02209
02210 case tTypeLong:
02211 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02212 if ( narray != 0 && narray == i ) {
02213 Tcerr << error << Tendl;
02214 break;
02215 }
02216 buffer[ i ] = (Tlong)( (Tlong*)theData )[ i ];
02217 nfilled ++;
02218 }
02219 break;
02220
02221 case tTypeUnsignedLong:
02222 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02223 if ( narray != 0 && narray == i ) {
02224 Tcerr << error << Tendl;
02225 break;
02226 }
02227 buffer[ i ] = (Tlong)( (TUlong*)theData )[ i ];
02228 nfilled ++;
02229 }
02230 break;
02231
02232 case tTypeString:
02233 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02234 if ( narray != 0 && narray == i ) {
02235 Tcerr << error << Tendl;
02236 break;
02237 }
02238 buffer[ i ] = (Tlong)strtol( (((Tstring*)theData )[ i ]).c_str(), 0, 0 );
02239 nfilled ++;
02240 }
02241 break;
02242
02243 case tTypeUnknown:
02244 case tTypeObject:
02245 default:
02246 static const Tstring head = "TDataElement::StorePrimitives: ";
02247 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
02248 Tcerr << head << "nothing to do." << Tendl;
02249 break;
02250 }
02251
02252 return nfilled;
02253 }
02254
02255 Tint TDataElement::StorePrimitives( TUlong* buffer, Tint narray ) const
02256 {
02257 Tint nfilled = 0;
02258 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
02259
02260 switch ( theElementType ) {
02261 case tTypeInt:
02262 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02263 if ( narray != 0 && narray == i ) {
02264 Tcerr << error << Tendl;
02265 break;
02266 }
02267 buffer[ i ] = (TUlong)( (Tint*)theData )[ i ];
02268 nfilled ++;
02269 }
02270 break;
02271
02272 case tTypeUnsignedInt:
02273 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02274 if ( narray != 0 && narray == i ) {
02275 Tcerr << error << Tendl;
02276 break;
02277 }
02278 buffer[ i ] = (TUlong)( (TUint*)theData )[ i ];
02279 nfilled ++;
02280 }
02281 break;
02282
02283 case tTypeUnsignedShort:
02284 case tTypeWord:
02285 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02286 if ( narray != 0 && narray == i ) {
02287 Tcerr << error << Tendl;
02288 break;
02289 }
02290 buffer[ i ] = (TUlong)( (TUshort*)theData )[ i ];
02291 nfilled ++;
02292 }
02293 break;
02294
02295 case tTypeDouble:
02296 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02297 if ( narray != 0 && narray == i ) {
02298 Tcerr << error << Tendl;
02299 break;
02300 }
02301 buffer[ i ] = (TUlong)( (Tdouble*)theData )[ i ];
02302 nfilled ++;
02303 }
02304 break;
02305
02306 case tTypeFloat:
02307 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02308 if ( narray != 0 && narray == i ) {
02309 Tcerr << error << Tendl;
02310 break;
02311 }
02312 buffer[ i ] = (TUlong)( (Tfloat*)theData )[ i ];
02313 nfilled ++;
02314 }
02315 break;
02316
02317 case tTypeShort:
02318 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02319 if ( narray != 0 && narray == i ) {
02320 Tcerr << error << Tendl;
02321 break;
02322 }
02323 buffer[ i ] = (TUlong)( (Tshort*)theData )[ i ];
02324 nfilled ++;
02325 }
02326 break;
02327
02328 case tTypeLong:
02329 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02330 if ( narray != 0 && narray == i ) {
02331 Tcerr << error << Tendl;
02332 break;
02333 }
02334 buffer[ i ] = (TUlong)( (Tlong*)theData )[ i ];
02335 nfilled ++;
02336 }
02337 break;
02338
02339 case tTypeUnsignedLong:
02340 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02341 if ( narray != 0 && narray == i ) {
02342 Tcerr << error << Tendl;
02343 break;
02344 }
02345 buffer[ i ] = (TUlong)( (TUlong*)theData )[ i ];
02346 nfilled ++;
02347 }
02348 break;
02349
02350 case tTypeString:
02351 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02352 if ( narray != 0 && narray == i ) {
02353 Tcerr << error << Tendl;
02354 break;
02355 }
02356 buffer[ i ] = (TUlong)strtoul( (((Tstring*)theData )[ i ]).c_str(), 0, 0 );
02357 nfilled ++;
02358 }
02359 break;
02360
02361 case tTypeUnknown:
02362 case tTypeObject:
02363 default:
02364 static const Tstring head = "TDataElement::StorePrimitives: ";
02365 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
02366 Tcerr << head << "nothing to do." << Tendl;
02367 break;
02368 }
02369
02370 return nfilled;
02371 }
02372
02373 Tint TDataElement::StorePrimitives( TUint* buffer, Tint narray ) const
02374 {
02375 Tint nfilled = 0;
02376 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
02377
02378 switch ( theElementType ) {
02379 case tTypeInt:
02380 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02381 if ( narray != 0 && narray == i ) {
02382 Tcerr << error << Tendl;
02383 break;
02384 }
02385 buffer[ i ] = (TUint)( (Tint*)theData )[ i ];
02386 nfilled ++;
02387 }
02388 break;
02389
02390 case tTypeUnsignedInt:
02391 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02392 if ( narray != 0 && narray == i ) {
02393 Tcerr << error << Tendl;
02394 break;
02395 }
02396 buffer[ i ] = (TUint)( (TUint*)theData )[ i ];
02397 nfilled ++;
02398 }
02399 break;
02400
02401 case tTypeUnsignedShort:
02402 case tTypeWord:
02403 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02404 if ( narray != 0 && narray == i ) {
02405 Tcerr << error << Tendl;
02406 break;
02407 }
02408 buffer[ i ] = (TUint)( (TUshort*)theData )[ i ];
02409 nfilled ++;
02410 }
02411 break;
02412
02413 case tTypeDouble:
02414 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02415 if ( narray != 0 && narray == i ) {
02416 Tcerr << error << Tendl;
02417 break;
02418 }
02419 buffer[ i ] = (TUint)( (Tdouble*)theData )[ i ];
02420 nfilled ++;
02421 }
02422 break;
02423
02424 case tTypeFloat:
02425 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02426 if ( narray != 0 && narray == i ) {
02427 Tcerr << error << Tendl;
02428 break;
02429 }
02430 buffer[ i ] = (TUint)( (Tfloat*)theData )[ i ];
02431 nfilled ++;
02432 }
02433 break;
02434
02435 case tTypeShort:
02436 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02437 if ( narray != 0 && narray == i ) {
02438 Tcerr << error << Tendl;
02439 break;
02440 }
02441 buffer[ i ] = (TUint)( (Tshort*)theData )[ i ];
02442 nfilled ++;
02443 }
02444 break;
02445
02446 case tTypeLong:
02447 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02448 if ( narray != 0 && narray == i ) {
02449 Tcerr << error << Tendl;
02450 break;
02451 }
02452 buffer[ i ] = (TUint)( (Tlong*)theData )[ i ];
02453 nfilled ++;
02454 }
02455 break;
02456
02457 case tTypeUnsignedLong:
02458 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02459 if ( narray != 0 && narray == i ) {
02460 Tcerr << error << Tendl;
02461 break;
02462 }
02463 buffer[ i ] = (TUint)( (TUlong*)theData )[ i ];
02464 nfilled ++;
02465 }
02466 break;
02467
02468 case tTypeString:
02469 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02470 if ( narray != 0 && narray == i ) {
02471 Tcerr << error << Tendl;
02472 break;
02473 }
02474 buffer[ i ] = (TUint)strtoul( (((Tstring*)theData )[ i ]).c_str(), 0, 0 );
02475 nfilled ++;
02476 }
02477 break;
02478
02479 case tTypeUnknown:
02480 case tTypeObject:
02481 default:
02482 static const Tstring head = "TDataElement::StorePrimitives: ";
02483 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
02484 Tcerr << head << "nothing to do." << Tendl;
02485 break;
02486 }
02487
02488 return nfilled;
02489 }
02490
02491 Tint TDataElement::StorePrimitives( Tstring* buffer, Tint narray ) const
02492 {
02493 Tint nfilled = 0;
02494 static const Tint digits = 0;
02495 static const Tstring error = "TDataElement::StorePrimitives: not enough space.";
02496
02497 switch ( theElementType ) {
02498 case tTypeInt:
02499 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02500 if ( narray != 0 && narray == i ) {
02501 Tcerr << error << Tendl;
02502 break;
02503 }
02504 buffer[ i ] = itostr( ( (Tint*)theData )[ i ], digits );
02505 nfilled ++;
02506 }
02507 break;
02508
02509 case tTypeUnsignedInt:
02510 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02511 if ( narray != 0 && narray == i ) {
02512 Tcerr << error << Tendl;
02513 break;
02514 }
02515 buffer[ i ] = ultostr( (TUlong)( (TUint*)theData )[ i ], digits );
02516 nfilled ++;
02517 }
02518 break;
02519
02520 case tTypeUnsignedShort:
02521 case tTypeWord:
02522 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02523 if ( narray != 0 && narray == i ) {
02524 Tcerr << error << Tendl;
02525 break;
02526 }
02527 buffer[ i ] = ultostr( (TUlong)( (TUshort*)theData )[ i ], digits );
02528 nfilled ++;
02529 }
02530 break;
02531
02532 case tTypeDouble:
02533 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02534 if ( narray != 0 && narray == i ) {
02535 Tcerr << error << Tendl;
02536 break;
02537 }
02538 buffer[ i ] = dtostr( ( (Tdouble*)theData )[ i ] );
02539 nfilled ++;
02540 }
02541 break;
02542
02543 case tTypeFloat:
02544 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02545 if ( narray != 0 && narray == i ) {
02546 Tcerr << error << Tendl;
02547 break;
02548 }
02549 buffer[ i ] = ftostr( ( (Tfloat*)theData )[ i ] );
02550 nfilled ++;
02551 }
02552 break;
02553
02554 case tTypeShort:
02555 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02556 if ( narray != 0 && narray == i ) {
02557 Tcerr << error << Tendl;
02558 break;
02559 }
02560 buffer[ i ] = itostr( (Tint)( (Tshort*)theData )[ i ], digits );
02561 nfilled ++;
02562 }
02563 break;
02564
02565 case tTypeLong:
02566 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02567 if ( narray != 0 && narray == i ) {
02568 Tcerr << error << Tendl;
02569 break;
02570 }
02571 buffer[ i ] = ltostr( ( (Tlong*)theData )[ i ], digits );
02572 nfilled ++;
02573 }
02574 break;
02575
02576 case tTypeUnsignedLong:
02577 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02578 if ( narray != 0 && narray == i ) {
02579 Tcerr << error << Tendl;
02580 break;
02581 }
02582 buffer[ i ] = ultostr( ( (TUlong*)theData )[ i ], digits );
02583 nfilled ++;
02584 }
02585 break;
02586
02587 case tTypeString:
02588 for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
02589 if ( narray != 0 && narray == i ) {
02590 Tcerr << error << Tendl;
02591 break;
02592 }
02593 buffer[ i ] = ( (Tstring*)theData )[ i ];
02594 nfilled ++;
02595 }
02596 break;
02597
02598 case tTypeUnknown:
02599 case tTypeObject:
02600 default:
02601 static const Tstring head = "TDataElement::StorePrimitives: ";
02602 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
02603 Tcerr << head << "nothing to do." << Tendl;
02604 break;
02605 }
02606
02607 return nfilled;
02608 }
02609
02610
02611 Tvoid TDataElement::StorePrimitive( Tint& buffer ) const
02612 {
02613 switch ( theElementType ) {
02614 case tTypeInt:
02615 buffer = (Tint)( *((Tint*)theData) );
02616 break;
02617
02618 case tTypeUnsignedInt:
02619 buffer = (Tint)( *((TUint*)theData) );
02620 break;
02621
02622 case tTypeUnsignedShort:
02623 case tTypeWord:
02624 buffer = (Tint)( *((TUshort*)theData) );
02625 break;
02626
02627 case tTypeDouble:
02628 buffer = (Tint)( *((Tdouble*)theData) );
02629 break;
02630
02631 case tTypeFloat:
02632 buffer = (Tint)( *((Tfloat*)theData) );
02633 break;
02634
02635 case tTypeShort:
02636 buffer = (Tint)( *((Tshort*)theData) );
02637 break;
02638
02639 case tTypeLong:
02640 buffer = (Tint)( *((Tlong*)theData) );
02641 break;
02642
02643 case tTypeUnsignedLong:
02644 buffer = (Tint)( *((TUlong*)theData) );
02645 break;
02646
02647 case tTypeString:
02648 buffer = (Tint)strtol( (*((Tstring*)theData)).c_str(), 0, 0 );
02649 break;
02650
02651 case tTypeUnknown:
02652 case tTypeObject:
02653 default:
02654 static const Tstring head = "TDataElement::StorePrimitive: ";
02655 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
02656 Tcerr << head << "nothing to do." << Tendl;
02657 break;
02658 }
02659
02660 return;
02661 }
02662
02663 Tvoid TDataElement::StorePrimitive( Tstring& buffer ) const
02664 {
02665 static const Tint digits = 0;
02666
02667 switch ( theElementType ) {
02668 case tTypeInt:
02669 buffer = itostr( *((Tint*)theData), digits );
02670 break;
02671
02672 case tTypeUnsignedInt:
02673 buffer = ultostr( (TUlong)(*(TUint*)theData), digits );
02674 break;
02675
02676 case tTypeUnsignedShort:
02677 case tTypeWord:
02678 buffer = ultostr( (TUlong)(*(TUshort*)theData), digits );
02679 break;
02680
02681 case tTypeDouble:
02682 buffer = dtostr( *((Tdouble*)theData) );
02683 break;
02684
02685 case tTypeFloat:
02686 buffer = ftostr( *((Tfloat*)theData) );
02687 break;
02688
02689 case tTypeShort:
02690 buffer = itostr( (Tint)(*(Tshort*)theData), digits );
02691 break;
02692
02693 case tTypeLong:
02694 buffer = ltostr( *((Tlong*)theData), digits );
02695 break;
02696
02697 case tTypeUnsignedLong:
02698 buffer = ultostr( *((TUlong*)theData), digits );
02699 break;
02700
02701 case tTypeString:
02702 buffer = (Tstring)(*(Tstring*)theData);
02703 break;
02704
02705 case tTypeUnknown:
02706 case tTypeObject:
02707 default:
02708 static const Tstring head = "TDataElement::StorePrimitives: ";
02709 Tcerr << head << "unresolved type information(" << theElementType << "." << Tendl;
02710 Tcerr << head << "nothing to do." << Tendl;
02711 break;
02712 }
02713
02714 return;
02715 }
02716
02717 Tvoid TDataElement::StorePrimitive( Tdouble& buffer ) const
02718 {
02719 switch ( theElementType ) {
02720 case tTypeInt:
02721 buffer = (Tdouble)( *((Tint*)theData) );
02722 break;
02723
02724 case tTypeUnsignedInt:
02725 buffer = (Tdouble)( *((TUint*)theData) );
02726 break;
02727
02728 case tTypeUnsignedShort:
02729 case tTypeWord:
02730 buffer = (Tdouble)( *((TUshort*)theData) );
02731 break;
02732
02733 case tTypeDouble:
02734 buffer = (Tdouble)( *((Tdouble*)theData) );
02735 break;
02736
02737 case tTypeFloat:
02738 buffer = (Tdouble)( *((Tfloat*)theData) );
02739 break;
02740
02741 case tTypeShort:
02742 buffer = (Tdouble)( *((Tshort*)theData) );
02743 break;
02744
02745 case tTypeLong:
02746 buffer = (Tdouble)( *((Tlong*)theData) );
02747 break;
02748
02749 case tTypeUnsignedLong:
02750 buffer = (Tdouble)( *((TUlong*)theData) );
02751 break;
02752
02753 case tTypeString:
02754 buffer = (Tdouble)strtod( (*((Tstring*)theData)).c_str(), 0 );
02755 break;
02756
02757 case tTypeUnknown:
02758 case tTypeObject:
02759 default:
02760 static const Tstring head = "TDataElement::StorePrimitive: ";
02761 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
02762 Tcerr << head << "nothing to do." << Tendl;
02763 break;
02764 }
02765
02766 return;
02767 }
02768
02769 Tvoid TDataElement::StorePrimitive( Tfloat& buffer ) const
02770 {
02771 switch ( theElementType ) {
02772 case tTypeInt:
02773 buffer = (Tfloat)( *((Tint*)theData) );
02774 break;
02775
02776 case tTypeUnsignedInt:
02777 buffer = (Tfloat)( *((TUint*)theData) );
02778 break;
02779
02780 case tTypeUnsignedShort:
02781 case tTypeWord:
02782 buffer = (Tfloat)( *((TUshort*)theData) );
02783 break;
02784
02785 case tTypeDouble:
02786 buffer = (Tfloat)( *((Tdouble*)theData) );
02787 break;
02788
02789 case tTypeFloat:
02790 buffer = (Tfloat)( *((Tfloat*)theData) );
02791 break;
02792
02793 case tTypeShort:
02794 buffer = (Tfloat)( *((Tshort*)theData) );
02795 break;
02796
02797 case tTypeLong:
02798 buffer = (Tfloat)( *((Tlong*)theData) );
02799 break;
02800
02801 case tTypeUnsignedLong:
02802 buffer = (Tfloat)( *((TUlong*)theData) );
02803 break;
02804
02805 case tTypeString:
02806 buffer = (Tfloat)strtof( (*((Tstring*)theData)).c_str(), 0 );
02807 break;
02808
02809 case tTypeUnknown:
02810 case tTypeObject:
02811 default:
02812 static const Tstring head = "TDataElement::StorePrimitive: ";
02813 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
02814 Tcerr << head << "nothing to do." << Tendl;
02815 break;
02816 }
02817
02818 return;
02819 }
02820
02821 Tvoid TDataElement::StorePrimitive( TUshort& buffer ) const
02822 {
02823 switch ( theElementType ) {
02824 case tTypeInt:
02825 buffer = (TUshort)( *((Tint*)theData) );
02826 break;
02827
02828 case tTypeUnsignedInt:
02829 buffer = (TUshort)( *((TUint*)theData) );
02830 break;
02831
02832 case tTypeUnsignedShort:
02833 case tTypeWord:
02834 buffer = (TUshort)( *((TUshort*)theData) );
02835 break;
02836
02837 case tTypeDouble:
02838 buffer = (TUshort)( *((Tdouble*)theData) );
02839 break;
02840
02841 case tTypeFloat:
02842 buffer = (TUshort)( *((Tfloat*)theData) );
02843 break;
02844
02845 case tTypeShort:
02846 buffer = (TUshort)( *((Tshort*)theData) );
02847 break;
02848
02849 case tTypeLong:
02850 buffer = (TUshort)( *((Tlong*)theData) );
02851 break;
02852
02853 case tTypeUnsignedLong:
02854 buffer = (TUshort)( *((TUlong*)theData) );
02855 break;
02856
02857 case tTypeString:
02858 buffer = (TUshort)strtoul( (*((Tstring*)theData)).c_str(), 0, 0 );
02859 break;
02860
02861 case tTypeUnknown:
02862 case tTypeObject:
02863 default:
02864 static const Tstring head = "TDataElement::StorePrimitive: ";
02865 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
02866 Tcerr << head << "nothing to do." << Tendl;
02867 break;
02868 }
02869
02870 return;
02871 }
02872
02873 Tvoid TDataElement::StorePrimitive( Tshort& buffer ) const
02874 {
02875 switch ( theElementType ) {
02876 case tTypeInt:
02877 buffer = (Tshort)( *((Tint*)theData) );
02878 break;
02879
02880 case tTypeUnsignedInt:
02881 buffer = (Tshort)( *((TUint*)theData) );
02882 break;
02883
02884 case tTypeUnsignedShort:
02885 case tTypeWord:
02886 buffer = (Tshort)( *((TUshort*)theData) );
02887 break;
02888
02889 case tTypeDouble:
02890 buffer = (Tshort)( *((Tdouble*)theData) );
02891 break;
02892
02893 case tTypeFloat:
02894 buffer = (Tshort)( *((Tfloat*)theData) );
02895 break;
02896
02897 case tTypeShort:
02898 buffer = (Tshort)( *((Tshort*)theData) );
02899 break;
02900
02901 case tTypeLong:
02902 buffer = (Tshort)( *((Tlong*)theData) );
02903 break;
02904
02905 case tTypeUnsignedLong:
02906 buffer = (Tshort)( *((TUlong*)theData) );
02907 break;
02908
02909 case tTypeString:
02910 buffer = (Tshort)strtol( (*((Tstring*)theData)).c_str(), 0, 0 );
02911 break;
02912
02913 case tTypeUnknown:
02914 case tTypeObject:
02915 default:
02916 static const Tstring head = "TDataElement::StorePrimitive: ";
02917 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
02918 Tcerr << head << "nothing to do." << Tendl;
02919 break;
02920 }
02921
02922 return;
02923 }
02924
02925 Tvoid TDataElement::StorePrimitive( Tlong& buffer ) const
02926 {
02927 switch ( theElementType ) {
02928 case tTypeInt:
02929 buffer = (Tlong)( *((Tint*)theData) );
02930 break;
02931
02932 case tTypeUnsignedInt:
02933 buffer = (Tlong)( *((TUint*)theData) );
02934 break;
02935
02936 case tTypeUnsignedShort:
02937 case tTypeWord:
02938 buffer = (Tlong)( *((TUshort*)theData) );
02939 break;
02940
02941 case tTypeDouble:
02942 buffer = (Tlong)( *((Tdouble*)theData) );
02943 break;
02944
02945 case tTypeFloat:
02946 buffer = (Tlong)( *((Tfloat*)theData) );
02947 break;
02948
02949 case tTypeShort:
02950 buffer = (Tlong)( *((Tshort*)theData) );
02951 break;
02952
02953 case tTypeLong:
02954 buffer = (Tlong)( *((Tlong*)theData) );
02955 break;
02956
02957 case tTypeUnsignedLong:
02958 buffer = (Tlong)( *((TUlong*)theData) );
02959 break;
02960
02961 case tTypeString:
02962 buffer = (Tlong)strtol( (*((Tstring*)theData)).c_str(), 0, 0 );
02963 break;
02964
02965 case tTypeUnknown:
02966 case tTypeObject:
02967 default:
02968 static const Tstring head = "TDataElement::StorePrimitive: ";
02969 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
02970 Tcerr << head << "nothing to do." << Tendl;
02971 break;
02972 }
02973
02974 return;
02975 }
02976
02977 Tvoid TDataElement::StorePrimitive( TUlong& buffer ) const
02978 {
02979 switch ( theElementType ) {
02980 case tTypeInt:
02981 buffer = (TUlong)( *((Tint*)theData) );
02982 break;
02983
02984 case tTypeUnsignedInt:
02985 buffer = (TUlong)( *((TUint*)theData) );
02986 break;
02987
02988 case tTypeUnsignedShort:
02989 case tTypeWord:
02990 buffer = (TUlong)( *((TUshort*)theData) );
02991 break;
02992
02993 case tTypeDouble:
02994 buffer = (TUlong)( *((Tdouble*)theData) );
02995 break;
02996
02997 case tTypeFloat:
02998 buffer = (TUlong)( *((Tfloat*)theData) );
02999 break;
03000
03001 case tTypeShort:
03002 buffer = (TUlong)( *((Tshort*)theData) );
03003 break;
03004
03005 case tTypeLong:
03006 buffer = (TUlong)( *((Tlong*)theData) );
03007 break;
03008
03009 case tTypeUnsignedLong:
03010 buffer = (TUlong)( *((TUlong*)theData) );
03011 break;
03012
03013 case tTypeString:
03014 buffer = (TUlong)strtol( (*((Tstring*)theData)).c_str(), 0, 0 );
03015 break;
03016
03017 case tTypeUnknown:
03018 case tTypeObject:
03019 default:
03020 static const Tstring head = "TDataElement::StorePrimitive: ";
03021 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
03022 Tcerr << head << "nothing to do." << Tendl;
03023 break;
03024 }
03025
03026 return;
03027 }
03028
03029 Tvoid TDataElement::StorePrimitive( TUint& buffer ) const
03030 {
03031 switch ( theElementType ) {
03032 case tTypeInt:
03033 buffer = (TUint)( *((Tint*)theData) );
03034 break;
03035
03036 case tTypeUnsignedInt:
03037 buffer = (TUint)( *((TUint*)theData) );
03038 break;
03039
03040 case tTypeUnsignedShort:
03041 case tTypeWord:
03042 buffer = (TUint)( *((TUshort*)theData) );
03043 break;
03044
03045 case tTypeDouble:
03046 buffer = (TUint)( *((Tdouble*)theData) );
03047 break;
03048
03049 case tTypeFloat:
03050 buffer = (TUint)( *((Tfloat*)theData) );
03051 break;
03052
03053 case tTypeShort:
03054 buffer = (TUint)( *((Tshort*)theData) );
03055 break;
03056
03057 case tTypeLong:
03058 buffer = (TUint)( *((Tlong*)theData) );
03059 break;
03060
03061 case tTypeUnsignedLong:
03062 buffer = (TUint)( *((TUlong*)theData) );
03063 break;
03064
03065 case tTypeString:
03066 buffer = (TUint)strtoul( (*((Tstring*)theData)).c_str(), 0, 0 );
03067 break;
03068
03069 case tTypeUnknown:
03070 case tTypeObject:
03071 default:
03072 static const Tstring head = "TDataElement::StorePrimitive: ";
03073 Tcerr << head << "unresolved type information(" << theElementType << ")." << Tendl;
03074 Tcerr << head << "nothing to do." << Tendl;
03075 break;
03076 }
03077
03078 return;
03079 }
03080
03081 #ifdef __CLDAQ_ROOT_DLL
03082 ClassImp(TDataElement)
03083 #endif