00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354 #include "StDbTable.h"
00355 #include "StDbBuffer.h"
00356 #include "typeAcceptor.hh"
00357 #include "StTableDescriptorI.h"
00358
00359 #ifndef __STDB_STANDALONE__
00360 #include "StMessMgr.h"
00361 #else
00362 #define LOG_DEBUG cout
00363 #define LOG_INFO cout
00364 #define LOG_WARN cout
00365 #define LOG_ERROR cerr
00366 #define LOG_FATAL cerr
00367 #define LOG_QA cout
00368 #define endm "\n"
00369 #endif
00370
00371 #include "StDbDefaults.hh"
00372 #include "StDbManager.hh"
00373 #include <string.h>
00374 #include "stdb_streams.h"
00375 #include <malloc.h>
00376 #ifdef __ROOT__
00377 ClassImp(StDbTable)
00378 #endif
00379
00380 #define __CLASS__ "StDbTable"
00381
00383 StDbTable::StDbTable(const char* tableName): StDbNode(tableName) { init();};
00384
00385 StDbTable::StDbTable(const char* tableName, int schemaID): StDbNode(tableName) { init(); mschemaID=schemaID; }
00386
00387
00388 StDbTable::StDbTable(StDbTable& table): StDbNode(table) {
00389
00390 init();
00391 mflavor=table.getFlavor();
00392 mdefaultFlavor = table.defaultFlavor();
00393 mprodTime = table.getProdTime();
00394
00395 mschemaID = table.getSchemaID();
00396 mrows = table.GetNRows();
00397 mhasDescriptor=table.hasDescriptor();
00398 mdescriptor=table.getDescriptorCpy();
00399
00400 mbeginTime.setDateTime(table.getBeginDateTime());
00401 mbeginTime.setUnixTime(table.getBeginTime());
00402 mendTime.setDateTime(table.getEndDateTime());
00403 mendTime.setUnixTime(table.getEndTime());
00404
00405 char* tmp = table.GetTable();
00406 if(mrows==0) mrows = 1;
00407 if(tmp) {
00408 unsigned int size = mrows*table.getTableSize();
00409 mdata = new char[size];
00410 memcpy(mdata,tmp,size);
00411 mhasData = true;
00412 }
00413
00414 setCstructName(table.printCstructName());
00415 setDataTable(table.printDataTable());
00416
00417 }
00418
00419 void StDbTable::init() {
00420 mflavor = 0;
00421 mstructName = 0;
00422 melementName = 0;
00423 mdataTable = 0;
00424 melementID = 0;
00425 mhasDescriptor = false;
00426 mdescriptor = 0;
00427 mdata = 0;
00428 mhasData = false;
00429 mrowsRequested = 0;
00430 mtimeVals = 0;
00431 mendTime.munixTime = 0;
00432 mrows = 0;
00433 mrowNumber = 0;
00434 mprodTime = StDbDefaults::Instance()->getProdTime();
00435 setDefaultFlavor();
00436 mschemaID = 0;
00437
00438 }
00439
00441 void StDbTable::setNodeInfo(StDbNode* node){
00442
00443 mdbType=node->getDbType();
00444 mdbDomain=node->getDbDomain();
00445 setDbName(node->printDbName());
00446 setVersion(node->printVersion());
00447 setNodeType(node->printNodeType());
00448 mnodeID=node->getNodeID();
00449 };
00450
00452 void StDbTable::setCstructName(const char* name){ mstructName=mstrDup(name); }
00453
00455 char* StDbTable::getCstructName() { return mstrDup(mstructName); }
00456
00458 void StDbTable::setDataTable(const char* name){ mdataTable=mstrDup(name); }
00459
00461 char* StDbTable::getDataTable() { return mstrDup(mdataTable); }
00462
00464 void
00465 StDbTable::setDefaultFlavor(){ setFlavor(StDbDefaults::Instance()->printFlavor());
00466 }
00467
00469 void StDbTable::setFlavor(const char* flavor) {
00470 if(!flavor) return;
00471 if(mflavor) delete [] mflavor;
00472 mflavor=new char[strlen(flavor)+1];
00473 strcpy(mflavor,flavor);
00474 mdefaultFlavor = StDbDefaults::Instance()->IsDefaultFlavor(mflavor);
00475 }
00476
00477 char* StDbTable::getFlavor() { return mstrDup(mflavor); }
00478
00479
00481 void
00482 StDbTable::addWrittenRows(int* dataID, int numRows, bool canRollBack){
00483
00484 for(int i=0; i<numRows; i++) mstoredData.addWrittenRow(dataID[i]);
00485 if(canRollBack)mcanRollBack=true;
00486
00487 }
00488
00489 int*
00490 StDbTable::getWrittenRows(int& nRows){
00491 return mstoredData.getDataIDs(nRows);
00492 }
00493 void StDbTable::commitData() { mstoredData.commit(); }
00494 void StDbTable::clearStoreInfo() { mstoredData.resetStoreInfo(); }
00495
00497 StTableDescriptorI*
00498 StDbTable::getDescriptorCpy() const { return mdescriptor->getCpy(); }
00499
00501 void
00502 StDbTable::setDescriptor(StTableDescriptorI* descriptor){
00503
00504 if(mdescriptor) delete mdescriptor;
00505 mdescriptor=descriptor;
00506 mhasDescriptor=true;
00507
00508
00509
00510 };
00511
00513 char* StDbTable::GetTable() { if(!mdata)createMemory(); return mdata;};
00514
00516 void*
00517 StDbTable::GetTableCpy() {
00518
00519 if(!mdata)return (void*)GetTable();
00520
00521 int len = mrows*getTableSize();
00522 char* c = (char*)calloc(mrows,getTableSize());
00523 memcpy(c,mdata,len);
00524
00525 return (void*)c;
00526 };
00527
00529 void
00530 StDbTable::SetTable(char* c, int nrows, int* idList) {
00531
00532 if(mdata){
00533 delete [] mdata;
00534 mdata = 0;
00535 }
00536 if(!idList){
00537 createMemory(nrows);
00538 } else {
00539 setElementID(idList,nrows);
00540 }
00541 int len = nrows*getTableSize();
00542 memcpy(mdata,c,len);
00543 mhasData=true;
00544
00545 }
00546
00548 void
00549 StDbTable::AddRows(char* c, int nrows) {
00550
00551 char* tmpData = duplicateData();
00552 int len1 = mrows*getTableSize();
00553 int len2 = nrows*getTableSize();
00554
00555 int newRows = nrows+mrows;
00556 if(mdata){
00557 delete [] mdata;
00558 mdata = 0;
00559 }
00560
00561 createMemory(newRows);
00562
00563 char* ptr= &mdata[0];
00564 memcpy(mdata,tmpData,len1);
00565 ptr+=len1;
00566 memcpy(ptr,c,len2);
00567
00568 delete [] tmpData;
00569 mhasData=true;
00570
00571 }
00572
00574 void*
00575 StDbTable::getDataValue(const char* name, int rowNumber){
00576
00577 void* retVal=0;
00578 int saveRowNum=mrowNumber;
00579 mrowNumber=rowNumber;
00580 int max = mdescriptor->getNumElements();
00581 char* ename=0;
00582 StTypeE type;
00583 unsigned int length;
00584 char * ptr;
00585
00586 for(int i=0;i<max;i++){
00587 getElementSpecs(i,ptr,ename,length,type);
00588 if(strcmp(name,ename)==0)break;
00589 if(ename) delete [] ename;
00590 ename=0;
00591 }
00592
00593 mrowNumber=saveRowNum;
00594 if(!ename) return retVal;
00595
00596 delete [] ename;
00597 return (void*)ptr;
00598 }
00599
00601 char*
00602 StDbTable::duplicateData() {
00603
00604 char* dup=0;
00605 int len1 = mrows*getTableSize();
00606 if(len1 !=0){
00607 dup=new char[len1];
00608 memcpy(dup,mdata,len1);
00609 }
00610 return dup;
00611 }
00612
00614
00615 bool
00616 StDbTable::createMemory(int nrows) {
00617 mrows = nrows;
00618 bool retVal = true;
00619 if(mrows==0) {
00620 if(mdata)delete [] mdata;
00621 mdata=0;
00622 return retVal;
00623 }
00624
00625
00626
00627
00628
00629 if(mdescriptor && mdescriptor->getNumElements()>0){
00630
00631
00632 int len;
00633 if (!mdescriptor->getTrowSize()){
00634 len = mrows*mdescriptor->getTotalSizeInBytes();
00635 }else{
00636 len = mrows*mdescriptor->getTrowSize();
00637 }
00638 if(len>0){
00639 if(mdata)delete [] mdata;
00640 mdata=new char[len];
00641 memset(mdata,0,len);
00642 int max = mdescriptor->getNumElements();
00643 char* name;
00644 StTypeE type;
00645 unsigned int length;
00646 char * ptr;
00647 for(int i=0; i<max;i++){
00648 getElementSpecs(i,ptr,name,length,type);
00649 if(type==Stchar)ptr='\0';
00650 delete [] name;
00651 }
00652 }
00653 } else {
00654 if(!mname){mname=mstrDup("Unknown");}
00655 retVal = false;
00656 }
00657
00658 return retVal;
00659 }
00660
00662 bool
00663 StDbTable::createMemory() {
00664 if(mdata)return true;
00665 if(mrows==0) mrows=1;
00666 return createMemory(mrows);
00667 }
00668
00670
00671 char*
00672 StDbTable::getElementName() { return mstrDup(melementName); };
00673
00674 void
00675 StDbTable::setElementName(const char* name) { melementName=mstrDup(name);};
00676
00677 void
00678 StDbTable::setElementID(int* elements, int nrows) {
00679
00680 createMemory(nrows);
00681
00682 if(melementID) delete [] melementID;
00683 if(nrows==0){
00684 melementID=0;
00685 return;
00686 }
00687 melementID = new int[nrows];
00688 memcpy(melementID, elements, nrows*sizeof(int));
00689 }
00690
00692 void StDbTable::resizeNumRows(int nrows){
00693
00694
00695
00696
00697 unsigned int rowsize;
00698 if (!mdescriptor->getTrowSize()) {
00699 rowsize=mdescriptor->getTotalSizeInBytes();
00700 }else{
00701 rowsize=mdescriptor->getTrowSize();
00702 }
00703 unsigned int len = mrows*rowsize;
00704 unsigned int newlen = nrows*rowsize;
00705
00706 if(mdata){
00707 char* oldData=new char[len];
00708 memcpy(oldData,mdata,len);
00709 delete [] mdata;
00710 mdata = new char[newlen];
00711 if(newlen<=len){
00712 memcpy(mdata,oldData,newlen);
00713 } else {
00714 memcpy(mdata,oldData,len);
00715 }
00716 delete [] oldData;
00717 }
00718
00719 mrows=nrows;
00720 return;
00721 }
00722
00723
00725 void
00726 StDbTable::addNRows(int numRows){
00727
00728 if(!mdescriptor) return;
00729
00730 int newRows = numRows+mrows;
00731
00732 unsigned int rowsize;
00733 if(!mdescriptor->getTrowSize()) {
00734 rowsize=mdescriptor->getTotalSizeInBytes();
00735 }else{
00736 rowsize=mdescriptor->getTrowSize();
00737 }
00738 unsigned int len = newRows*rowsize;
00739 char* newData = new char[len];
00740 memset(newData,0,len);
00741 if(mdata)memcpy(newData,mdata,mrows*rowsize);
00742 char* p1 = newData;
00743 p1+=mrows*rowsize;
00744 memset(p1,0,numRows*rowsize);
00745 if(mdata)delete [] mdata;
00746 mdata=newData;
00747
00748 resizeElementID(newRows);
00749 };
00750
00752 void
00753 StDbTable::resizeElementID(int numRows){
00754
00755 int * newElements=new int[numRows];
00756 if(melementID) {
00757 memcpy(newElements,melementID,mrows*sizeof(int));
00758 delete [] melementID;
00759 }
00760 melementID=newElements;
00761 mrows = numRows;
00762
00763 };
00764
00766 void
00767 StDbTable::addNElements(int* elements, int newRows){
00768
00769
00770 if(!melementID) return;
00771
00772 int i,j,k;
00773 k=mrows-newRows;
00774 if(k<0)return;
00775 j=0;
00776 for(i=k;i<mrows;i++){
00777 melementID[i]=elements[j];
00778 j++;
00779 }
00780
00781 }
00782
00784 void
00785 StDbTable::StreamAccessor(typeAcceptor* accept, bool isReading){
00786
00787 int len = 1;
00788 accept->pass((char*)"schemaID",mschemaID,len);
00789
00790 if(isReading){
00791 if(mbeginTime.mdateTime) delete [] mbeginTime.mdateTime;
00792 if(mversion)delete [] mversion;
00793 if(melementID)delete [] melementID;
00794 } else {
00795 if(!melementID){
00796 melementID = new int[mrows];
00797 for(int i=0;i<mrows;i++)melementID[i]=i;
00798 }
00799 }
00800 accept->pass((char*)"beginTime",mbeginTime.mdateTime,len);
00801 accept->pass((char*)"version",mversion,len);
00802 accept->pass((char*)"elementID",melementID, mrows);
00803 }
00804
00806 void
00807 StDbTable::StreamAccessor(StDbBufferI* buff, bool isReading){
00808
00809 bool ClientMode;
00810 if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00811
00812 int rowID;
00813 if(!melementID){
00814 melementID = new int[mrows];
00815 for(int i=0;i<mrows;i++)melementID[i]=i;
00816 }
00817
00818 if(isReading){
00819 buff->ReadScalar(rowID,"elementID");
00820 melementID[mrowNumber]=rowID;
00821
00822 if(mrowNumber==0){
00823 buff->ReadScalar(mschemaID,"schemaID");
00824 if(mversion) delete [] mversion;
00825 buff->ReadScalar(mversion,"version");
00826 } else {
00827 unsigned int bTime;
00828 buff->ReadScalar(bTime,"beginTime");
00829 if(bTime>mbeginTime.munixTime)mbeginTime.munixTime=bTime;
00830 }
00831
00832 } else {
00833
00834 buff->WriteScalar(mschemaID,"schemaID");
00835 buff->WriteScalar(mbeginTime.munixTime,"beginTime");
00836 if(mversion)buff->WriteScalar(mversion,"version");
00837 rowID = melementID[mrowNumber];
00838 buff->WriteScalar(rowID,"elementID");
00839 }
00840
00841 if(!ClientMode)buff->SetStorageMode();
00842
00843 }
00844
00846 void
00847 StDbTable::getElementSpecs(int elementNum, char*& c, char*& name, unsigned int& length,StTypeE& type){
00848
00849 int tRow = mdescriptor->getTrowSize();
00850 unsigned int tSize=mdescriptor->getTotalSizeInBytes();
00851 unsigned int rowIndex;
00852 if (!tRow) {
00853 rowIndex = ((unsigned int)mrowNumber)*tSize;
00854 }else{
00855 rowIndex = ((unsigned int)mrowNumber)*tRow;
00856 }
00857 int i = elementNum;
00858 c = &mdata[rowIndex];
00859 int current = mdescriptor->getElementOffset(i);
00860 c += current;
00861 name = mdescriptor->getElementName(i);
00862 length = mdescriptor->getElementLength(i);;
00863 type = mdescriptor->getElementType(i);
00864
00865 return;
00866 }
00867
00869 void
00870 StDbTable::dbStreamer(StDbBufferI* buff, bool isReading){
00871
00872 int max = mdescriptor->getNumElements();
00873 char* name;
00874 StTypeE type;
00875 unsigned int length;
00876 char* ptr;
00877
00878 bool ClientMode;
00879 if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00880
00881 if(createMemory() && mrowNumber < mrows){
00882
00883 for(int i=0; i<max; i++){
00884 getElementSpecs(i,ptr,name,length,type);
00885 if(isReading){
00886 ReadElement(ptr,name,length,type,(StDbBuffer*)buff);
00887 } else {
00888 WriteElement(ptr,name,length,type,(StDbBuffer*)buff);
00889 }
00890 delete [] name;
00891 }
00892
00893 mrowNumber++;
00894 if(isReading)mhasData=true;
00895
00896 } else {
00897 LOG_ERROR << "dbStreamer:: more rows delivered than allocated " << endm;
00898 }
00899 if(!ClientMode)buff->SetStorageMode();
00900 }
00901
00902
00904 void
00905 StDbTable::dbStreamerWrite(StDbBufferI* buff){
00906
00907 int max = mdescriptor->getNumElements();
00908 char* name;
00909 StTypeE type;
00910 unsigned int length;
00911 char* ptr;
00912
00913
00914
00915
00916
00917
00918 if(mrowNumber<mrows){
00919 for(int i=0; i<max; i++){
00920 getElementSpecs(i,ptr,name,length,type);
00921 WriteElement(ptr,name,length,type,(StDbBuffer*)buff);
00922 delete [] name;
00923 }
00924 mrowNumber++;
00925 }
00926 }
00927
00929
00930 void
00931 StDbTable::dbTableStreamer(StDbBufferI* buff, const char* name, bool isReading){
00932
00933 int max = mdescriptor->getNumElements();
00934
00935 StTypeE type = mdescriptor->getElementType(0);
00936 unsigned int length = (unsigned int) mrows*max;
00937
00938 char* ptr;
00939
00940 bool ClientMode;
00941 if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00942
00943 if(createMemory() && mrowNumber < mrows){
00944
00945 ptr = &mdata[0];
00946
00947 if(isReading){
00948 ReadElement(ptr,(char *) name,length,type,(StDbBuffer*)buff);
00949 } else {
00950 WriteElement(ptr,(char *) name,length,type,(StDbBuffer*)buff);
00951 }
00952 mrowNumber=mrows;
00953 if(isReading) mhasData=true;
00954 }
00955
00956 if(!ClientMode)buff->SetStorageMode();
00957 }
00958
00959
00961
00962 void
00963 StDbTable::dbStreamer(typeAcceptor* accept, bool isReading){
00964
00965 int max = mdescriptor->getNumElements();
00966 char* name;
00967 StTypeE type;
00968 unsigned int length;
00969 char* ptr;
00970
00971 if(createMemory() && mrowNumber < mrows){
00972
00973 if(isReading){
00974 for(int i=0; i<max; i++){
00975 getElementSpecs(i,ptr,name,length,type);
00976 PassInElement(ptr,name,length,type,accept);
00977 delete [] name;
00978 }
00979 mhasData=true;
00980 } else {
00981 for(int i=0; i<max; i++){
00982 getElementSpecs(i,ptr,name,length,type);
00983 PassOutElement(ptr,name,length,type,accept);
00984 delete [] name;
00985 }
00986 }
00987
00988 mrowNumber++;
00989 }
00990
00991 }
00992
00994
00995 void
00996 StDbTable::ReadElement(char*& ptr, char* name, int len, StTypeE type, StDbBuffer* buff){
00997
00998 char* mchar; unsigned char* muchar; short* mshort; unsigned short* mushort;
00999 int* mint; unsigned int* muint; long* mlong; unsigned long* mulong;
01000 long long* mlonglong;
01001 float* mfloat; double* mdouble;
01002
01003 int blen;
01004
01005 switch (type) {
01006 case Stchar:
01007 {
01008 StString cn;
01009 cn<<name<<".text"; const char* commentName = (cn.str()).c_str();
01010 mchar = 0;
01011 if(!buff->ReadScalar(mchar,commentName))buff->ReadScalar(mchar,name);
01012 if(mchar){
01013 int len1=strlen(mchar);
01014 if(len>len1) len=len1;
01015 strncpy(ptr,mchar,len);
01016 delete [] mchar;
01017 } else {
01018 *ptr='\0';
01019 printNoDataReturned(name);
01020 }
01021 break;
01022 }
01023 case Stuchar:
01024 {
01025 if(buff->ReadArray(muchar,blen,name)){
01026 if(len>blen)len=blen;
01027 memcpy(ptr,muchar,len*sizeof(unsigned char));
01028 delete [] muchar;
01029 } else { printNoDataReturned(name); }
01030 break;
01031 }
01032 case Stshort:
01033 {
01034 if(buff->ReadArray(mshort,blen,name)){
01035 if(len>blen)len=blen;
01036 memcpy(ptr,mshort,len*sizeof(short));
01037 delete [] mshort;
01038 } else { printNoDataReturned(name); }
01039 break;
01040 }
01041 case Stushort:
01042 {
01043 if(buff->ReadArray(mushort,blen,name)){
01044 if(len>blen)len=blen;
01045 memcpy(ptr,mushort,len*sizeof(unsigned short));
01046 delete [] mushort;
01047 } else { printNoDataReturned(name); }
01048 break;
01049 }
01050 case Stint:
01051 {
01052 if(buff->ReadArray(mint,blen,name)){
01053 if(len>blen)len=blen;
01054 memcpy(ptr,mint,len*sizeof(int));
01055 delete [] mint;
01056 } else { printNoDataReturned(name); }
01057 break;
01058 }
01059 case Stuint:
01060 {
01061 if(buff->ReadArray(muint,blen,name)){
01062 if(len>blen)len=blen;
01063 memcpy(ptr,muint,len*sizeof(unsigned int));
01064 delete [] muint;
01065 } else { printNoDataReturned(name); }
01066 break;
01067 }
01068 case Stlong:
01069 {
01070 if(buff->ReadArray(mlong,blen,name)){
01071 if(len>blen)len=blen;
01072 memcpy(ptr,mlong,len*sizeof(long));
01073 delete [] mlong;
01074 } else { printNoDataReturned(name); }
01075 break;
01076 }
01077 case Stulong:
01078 {
01079 if(buff->ReadArray(mulong,blen,name)){
01080 if(len>blen)len=blen;
01081 memcpy(ptr,mulong,len*sizeof(unsigned long));
01082 delete [] mulong;
01083 } else { printNoDataReturned(name); }
01084 break;
01085 }
01086 case Stlonglong:
01087 {
01088 if(buff->ReadArray(mlonglong,blen,name)){
01089 if(len>blen)len=blen;
01090 memcpy(ptr,mlonglong,len*sizeof(long long));
01091 delete [] mlonglong;
01092 } else { printNoDataReturned(name); }
01093 break;
01094 }
01095 case Stfloat:
01096 {
01097 if(buff->ReadArray(mfloat,blen,name)){
01098 if(len>blen)len=blen;
01099 memcpy(ptr,mfloat,len*sizeof(float));
01100 delete [] mfloat;
01101 } else { printNoDataReturned(name); }
01102 break;
01103 }
01104 case Stdouble:
01105 {
01106 if(buff->ReadArray(mdouble,blen,name)){
01107 if(len>blen)len=blen;
01108 memcpy(ptr,mdouble,len*sizeof(double));
01109 delete [] mdouble;
01110 } else { printNoDataReturned(name); }
01111 break;
01112 }
01113 case Stmaxtype:
01114 printNoDataReturned(name);
01115 break;
01116 }
01117
01118 }
01119
01121
01122 void
01123 StDbTable::WriteElement(char* ptr, char* name, int len, StTypeE type, StDbBuffer* buff){
01124
01125 switch (type) {
01126 case Stchar:
01127 {
01128 char* mchar = ptr;
01129 buff->WriteScalar(mchar,name);
01130 break;
01131 }
01132 case Stuchar:
01133 {
01134 unsigned char* muchar = (unsigned char*)ptr;
01135 buff->WriteArray(muchar,len,name);
01136 break;
01137 }
01138 case Stshort:
01139 {
01140 short* mshort = (short*) ptr;
01141 buff->WriteArray(mshort ,len,name);
01142 break;
01143 }
01144 case Stushort:
01145 {
01146 unsigned short* mushort = (unsigned short*) ptr;
01147 buff->WriteArray(mushort,len,name);
01148 break;
01149 }
01150 case Stint:
01151 {
01152 int* mint = (int*)ptr;
01153 buff->WriteArray(mint,len,name);
01154 break;
01155 }
01156 case Stuint:
01157 {
01158 unsigned int* muint = (unsigned int*) ptr;
01159 buff->WriteArray(muint,len,name);
01160 break;
01161 }
01162 case Stlong:
01163 {
01164 long* mlong = (long*) ptr;
01165
01166 buff->WriteArray(mlong,len,name);
01167 break;
01168 }
01169 case Stulong:
01170 {
01171 unsigned long* mulong = (unsigned long*) ptr;
01172 buff->WriteArray(mulong,len,name);
01173 break;
01174 }
01175 case Stlonglong:
01176 {
01177 long long* mlonglong = (long long*) ptr;
01178 buff->WriteArray(mlonglong,len,name);
01179 break;
01180 }
01181 case Stfloat:
01182 {
01183 float* mfloat = (float*) ptr;
01184
01185 buff->WriteArray(mfloat,len,name);
01186 break;
01187 }
01188 case Stdouble:
01189 {
01190 double* mdouble = (double*) ptr;
01191 buff->WriteArray(mdouble,len,name);
01192 break;
01193 }
01194 case Stmaxtype:
01195 break;
01196 }
01197
01198 }
01199
01201 void
01202 StDbTable::PassInElement(char* ptr, char* name, int len, StTypeE type, typeAcceptor* accept){
01203
01204
01205 switch (type) {
01206 case Stchar:
01207 {
01208 char* data;
01209 accept->pass(name,data,len);
01210 memcpy(ptr,data,len);
01211 delete [] data;
01212 break;
01213 }
01214 case Stuchar:
01215 {
01216 unsigned char* data;
01217 accept->pass(name,data,len);
01218 memcpy(ptr,data,len);
01219 delete [] data;
01220 break;
01221 }
01222 case Stshort:
01223 {
01224 short* data;
01225 accept->pass(name,data,len);
01226 memcpy(ptr,data,len*sizeof(short));
01227 delete [] data;
01228 break;
01229 }
01230 case Stushort:
01231 {
01232 unsigned short* data;
01233 accept->pass(name,data,len);
01234 memcpy(ptr,data,len*sizeof(short));
01235 delete [] data;
01236 break;
01237 }
01238 case Stint:
01239 {
01240 int* data;
01241 accept->pass(name,data,len);
01242 memcpy(ptr,data,len*sizeof(int));
01243 delete [] data;
01244 break;
01245 }
01246 case Stuint:
01247 {
01248 unsigned int* data;
01249 accept->pass(name,data,len);
01250 memcpy(ptr,data,len*sizeof(int));
01251 delete [] data;
01252 break;
01253 }
01254 case Stlong:
01255 {
01256 long* data;
01257 accept->pass(name,data,len);
01258 memcpy(ptr,data,len*sizeof(long));
01259 delete [] data;
01260 break;
01261 }
01262 case Stulong:
01263 {
01264 unsigned long* data;
01265 accept->pass(name,data,len);
01266 memcpy(ptr,data,len*sizeof(long));
01267 delete [] data;
01268 break;
01269 }
01270 case Stlonglong:
01271 {
01272 long long* data;
01273 accept->pass(name,data,len);
01274 memcpy(ptr,data,len*sizeof(long long));
01275 delete [] data;
01276 break;
01277 }
01278 case Stfloat:
01279 {
01280 float* data;
01281 accept->pass(name,data,len);
01282 memcpy(ptr,data,len*sizeof(float));
01283 delete [] data;
01284 break;
01285 }
01286 case Stdouble:
01287 {
01288 double* data;
01289 accept->pass(name,data,len);
01290 memcpy(ptr,data,len*sizeof(double));
01291 delete [] data;
01292 break;
01293 }
01294 case Stmaxtype:
01295
01296 break;
01297 }
01298 }
01299
01301
01302 void
01303 StDbTable::PassOutElement(char* ptr, char* name, int len, StTypeE type, typeAcceptor* accept){
01304
01305 switch (type) {
01306 case Stchar:
01307 {
01308 accept->pass(name,ptr,len);
01309 break;
01310 }
01311 case Stuchar:
01312 {
01313 unsigned char* muchar = (unsigned char*)ptr;
01314 accept->pass(name, muchar,len);
01315 break;
01316 }
01317 case Stshort:
01318 {
01319 short* mshort = (short*)ptr;
01320 if(len==1){
01321 accept->pass(name, *mshort ,len);
01322 } else {
01323 accept->pass(name,mshort,len);
01324 }
01325 break;
01326 }
01327 case Stushort:
01328 {
01329 unsigned short* mushort = (unsigned short*)ptr;
01330 if(len==1){
01331 accept->pass(name, *mushort ,len);
01332 } else {
01333 accept->pass(name,mushort,len);
01334 }
01335 break;
01336 }
01337 case Stint:
01338 {
01339 int* mint = (int*)ptr;
01340 if(len==1){
01341 accept->pass(name, *mint ,len);
01342 } else {
01343 accept->pass(name,mint,len);
01344 }
01345 break;
01346 }
01347 case Stuint:
01348 {
01349 unsigned int* muint = (unsigned int*)ptr;
01350 if(len==1){
01351 accept->pass(name, *muint ,len);
01352 } else {
01353 accept->pass(name,muint,len);
01354 }
01355 break;
01356 }
01357 case Stlong:
01358 {
01359 long* mlong = (long*)ptr;
01360 if(len==1){
01361 accept->pass(name, *mlong ,len);
01362 } else {
01363 accept->pass(name,mlong,len);
01364 }
01365 break;
01366 }
01367 case Stulong:
01368 {
01369 unsigned long* mulong = (unsigned long*)ptr;
01370 if(len==1){
01371 accept->pass(name, *mulong ,len);
01372 } else {
01373 accept->pass(name,mulong,len);
01374 }
01375 break;
01376 }
01377 case Stlonglong:
01378 {
01379 long long* mlonglong = (long long*)ptr;
01380 if(len==1){
01381 accept->pass(name, *mlonglong ,len);
01382 } else {
01383 accept->pass(name,mlonglong,len);
01384 }
01385 break;
01386 }
01387 case Stfloat:
01388 {
01389 float* mfloat = (float*)ptr;
01390 if(len==1){
01391 accept->pass(name, *mfloat ,len);
01392 } else {
01393 accept->pass(name,mfloat,len);
01394 }
01395 break;
01396 }
01397 case Stdouble:
01398 {
01399 double* mdouble = (double*)ptr;
01400 if(len==1){
01401 accept->pass(name, *mdouble ,len);
01402 } else {
01403 accept->pass(name,mdouble,len);
01404 }
01405 break;
01406 }
01407 case Stmaxtype:
01408
01409 break;
01410 }
01411 }
01412
01414 void
01415 StDbTable::checkDescriptor(){
01416
01417 int i = mdescriptor->getNumElements();
01418 unsigned int size = mdescriptor->getTotalSizeInBytes();
01419 cout <<"Descriptor for Table = " << mname<<endl;
01420 cout <<" number of elements = "<<i<< " with size = " << size <<" TrowSize = " << mdescriptor->getTrowSize()<< endl;
01421 for(int k=0; k<i;k++){
01422 cout <<"Name = " << mdescriptor->getElementName(k);
01423 cout <<" size = " << mdescriptor->getElementSize(k);
01424 cout <<" offset = " <<mdescriptor->getElementOffset(k);
01425 cout <<" type = " <<(int)mdescriptor->getElementType(k) << endl;
01426 }
01427 }
01428
01429
01430 void StDbTable::printNoDataReturned(const char* elementName){
01431
01432 StString emess;
01433 emess<<" No data return from table="<<printName()<<" column="<<elementName;
01434 StDbManager::Instance()->printInfo((emess.str()).c_str(),dbMWarn,__LINE__,__CLASS__,"ReadElement(ptr,name,len,type,buffer)");
01435 }
01436
01437 #undef __CLASS__
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448
01449
