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

TDataElement.cc

解説を見る。
00001 // =====================================================================
00002 //  $Id: TDataElement.cc,v 1.9 2004/03/07 10:30:30 goiwai Exp $
00003 //  $Name: CLDAQ-1-14-03 $
00004 //  $Log: TDataElement.cc,v $
00005 //  Revision 1.9  2004/03/07 10:30:30  goiwai
00006 //  ROOTに組みこむためのおまじないマクロを埋めこみました。
00007 //  全てにおいて完全に動作するわけではありません。
00008 //
00009 //  Revision 1.8  2004/03/07 05:09:10  goiwai
00010 //  なぜかinlineがついてたのではずしたよ。
00011 //
00012 //  Revision 1.7  2003/12/06 10:59:11  goiwai
00013 //  Serialize(Tvoid*) -> Serialize(const Tvoid*)に変更しました.
00014 //  Deserialize(const Tvoid*)を追加しました.
00015 //  手抜きの実装なので,バッファオーバーフローの可能性があります.
00016 //  Reallocate()とかするような仕組みが必要です.
00017 //
00018 //  Revision 1.6  2003/11/04 12:03:05  goiwai
00019 //  ==演算子と!=演算子を実装しました.具体的には
00020 //  if ( record == "String" ) {
00021 //    hoeghoge;
00022 //  }
00023 //  のような使い方が出来ます.単純に theID メンバとを比較して結果を返します.
00024 //
00025 //  Revision 1.5  2003/10/06 16:42:19  goiwai
00026 //  *** empty log message ***
00027 //
00028 //  Revision 1.4  2003/08/20 21:49:02  goiwai
00029 //  TDataElementクラスにStorePrimitive()メソッドを追加しました.
00030 //  StorePrimitives()という似たようなメソッドもありますが,こちらは,1つ以上
00031 //  プリミティブデータを取得するメソッドであるのに対して,この
00032 //  StorePrimitive()メソッドは1つのデータのみ取得します.
00033 //
00034 //    type data;
00035 //    element.StorePrimitives( &data );
00036 //    // ----
00037 //    type data;
00038 //    element.StorePrimitive( data );
00039 //
00040 //  上のふたつの処理は同じ動作をします.
00041 //  型は内部で解決される(その分遅い)ので,特に気にする必要はありません.
00042 //
00043 //  Revision 1.3  2003/07/30 16:17:50  goiwai
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   // record size + object type + object id + element type + number of primitives
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   // write record size
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   // write object type
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   // write object ID
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   // write element type
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   // write number of primitives
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   // send record size
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   // send object type
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   // send object ID
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   // send element type
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   // send number of primitives
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   // write record size
00801   *( (Tint*)ptr ) = GetRecordSize();
00802   datasize += Tsizeof( Tint );
00803   ( (Tint*)ptr ) ++;
00804 
00805 
00806   // write object type
00807   *( (Tobject_t*)ptr ) = theObjectType;
00808   datasize += Tsizeof( Tobject_t );
00809   ( (Tobject_t*)ptr ) ++;
00810 
00811 
00812   // write object ID
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   // write element type
00831   *( (Telement_t*)ptr ) = theElementType;
00832   datasize += Tsizeof( Telement_t );
00833   ( (Telement_t*)ptr ) ++;
00834 
00835 
00836   // write number of primitives
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         // write Number of characters
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           // write a character
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   // write record size
01250   *( (Tint*)p ) = GetRecordSize();
01251   ( (Tint*)p ) ++;
01252   datasize += Tsizeof( Tint );
01253 
01254 
01255   // write object type
01256   *( (Tobject_t*)p ) = theObjectType;
01257   ( (Tobject_t*)p ) ++;
01258   datasize += Tsizeof( Tobject_t );
01259 
01260 
01261   // write object ID
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   // write element type
01280   *( (Telement_t*)p ) = theElementType;
01281   ( (Telement_t*)p ) ++;
01282   datasize += Tsizeof( Telement_t );
01283 
01284 
01285   // write number of primitives
01286   *( (Tint*)p ) = theNumberOfPrimitives;
01287   ( (Tint*)p ) ++;
01288   datasize += Tsizeof( Tint );
01289 
01290 
01291   // write primitives
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   // read record size
01404   ( (Tint*)p ) ++;
01405   datasize += Tsizeof( Tint );
01406 
01407 
01408   // read object type
01409   theObjectType = *( (Tobject_t*)p );
01410   ( (Tobject_t*)p ) ++;
01411   datasize += Tsizeof( Tobject_t );
01412 
01413 
01414 
01415   // read object ID
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   // read element type
01431   theElementType = *( (Telement_t*)p );
01432   ( (Telement_t*)p ) ++;
01433   datasize += Tsizeof( Telement_t );
01434 
01435 
01436   // read number of primitives
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          // read string
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


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