Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

StDbTable Class Reference

#include <StDbTable.h>

Inheritance diagram for StDbTable:

StDbNode List of all members.

Public Member Functions

 StDbTable (const char *tableName)
 StDbTable (const char *tableName, int schemaID)
 StDbTable (StDbTable &table)
virtual ~StDbTable ()
virtual bool IsTable () const
virtual void setNodeInfo (StDbNode *node)
virtual unsigned int getTableSize () const
virtual char * getCstructName ()
virtual char * printCstructName ()
virtual void setCstructName (const char *name)
virtual void setDataTable (const char *name)
virtual char * getDataTable ()
virtual char * printDataTable ()
virtual char * getFlavor ()
virtual char * printFlavor ()
virtual void setFlavor (const char *flavor)
virtual bool defaultFlavor () const
virtual void setDefaultFlavor ()
virtual unsigned int getProdTime ()
virtual void setProdTime (unsigned int ptime)
virtual unsigned int getEndTime () const
virtual char * getEndDateTime ()
virtual void setEndTime (unsigned int time)
virtual void setEndTime (const char *time)
virtual unsigned int getBeginTime () const
virtual char * getBeginDateTime ()
virtual void setBeginTime (unsigned int time)
virtual void setBeginTime (const char *time)
virtual unsigned int getEndStoreTime () const
virtual char * getEndStoreDateTime ()
virtual void setEndStoreTime (unsigned int time)
virtual void setEndStoreTime (const char *time)
virtual int * getElementID (int &nrows)
virtual int getRowID (int rowNumber) const
virtual char * getElementName ()
virtual char * printElementName ()
virtual void setElementName (const char *ename)
virtual void setElementID (int *elements, int nrows)
virtual void setBaseLine (bool baseLine)
virtual void setIndexed (bool indexed)
virtual void setBinary (bool abinary)
virtual bool IsBaseLine () const
virtual bool IsIndexed () const
virtual bool IsBinary () const
virtual int getSchemaID () const
virtual void setSchemaID (int id)
virtual void addWrittenRows (int *dataID, int numRows, bool canRollBack=false)
virtual int * getWrittenRows (int &numRows)
virtual void commitData ()
virtual void clearStoreInfo ()
virtual unsigned int * getTimeValues ()
virtual unsigned int getMaxTime ()
virtual void setTimeValues (unsigned int *timeValues)
virtual StTableDescriptorI * getDescriptorCpy () const
virtual StTableDescriptorI * getDescriptor ()
virtual void setDescriptor (StTableDescriptorI *descriptor)
virtual bool hasDescriptor () const
void checkDescriptor ()
virtual StDbTable * Clone ()
virtual char * GetTable ()
virtual void * GetTableCpy ()
virtual void SetTable (char *data, int nrows, int *idList=0)
 calloc'd version of data for StRoot

virtual void AddRows (char *data, int nrows)
virtual int GetNRows () const
virtual void setRowNumber (int row=0)
virtual bool hasData () const
virtual void * getDataValue (const char *name, int rowNumber=0)
virtual int getRowLimit () const
virtual void setRowLimit (int nrows)
virtual void addNRows (int newRows)
virtual void addNElements (int *elements, int newRows)
virtual void resizeNumRows (int nrows)
virtual void resizeElementID (int numRows)
virtual void StreamAccessor (typeAcceptor *accept, bool isReading)
virtual void dbStreamer (typeAcceptor *accept, bool isReading)
virtual void StreamAccessor (StDbBufferI *buff, bool isReading)
virtual void dbStreamer (StDbBufferI *buff, bool isReading)
virtual void dbStreamerWrite (StDbBufferI *buff)
virtual void dbTableStreamer (StDbBufferI *buff, const char *name, bool isReading)

Protected Member Functions

virtual void ReadElement (char *&ptr, char *name, int length, StTypeE type, StDbBuffer *buff)
virtual void WriteElement (char *ptr, char *name, int length, StTypeE type, StDbBuffer *buff)
virtual void PassOutElement (char *ptr, char *name, int length, StTypeE type, typeAcceptor *accept)
virtual void PassInElement (char *ptr, char *name, int length, StTypeE type, typeAcceptor *accept)
virtual void getElementSpecs (int elementNum, char *&c, char *&name, unsigned int &length, StTypeE &type)
bool createMemory ()
bool createMemory (int nrows)
char * duplicateData ()
void init ()
void printNoDataReturned (const char *elementName)

Protected Attributes

char * mflavor
bool mdefaultFlavor
unsigned int mprodTime
StDbTime mbeginTime
 validity interval

StDbTime mendTime
StDbTime mendStoreTime
char * mstructName
char * melementName
bool mIsBaseLine
bool mIsBinary
bool mIsIndexed
char * mdataTable
int mschemaID
int * melementID
StDbStoreInfo mstoredData
 for rolling back stores

bool mhasDescriptor
 c-struct descriptor information

StTableDescriptorI * mdescriptor
char * mdata
 data & num of rows

int mrows
int mrowNumber
bool mhasData
int mrowsRequested
unsigned int * mtimeVals

Constructor & Destructor Documentation

StDbTable::StDbTable (  const char *  tableName  ) 
 

Definition at line 346 of file StDbTable.cc. 

00346 : StDbNode(tableName) { init();};

StDbTable::StDbTable (  const char *  tableName,
int  schemaID
) 
 

Definition at line 348 of file StDbTable.cc. 

00348 : StDbNode(tableName) {  init(); mschemaID=schemaID; }

StDbTable::StDbTable (  StDbTable &  table  ) 
 

Definition at line 351 of file StDbTable.cc. 

00351                                     : StDbNode(table) {
00352 
00353  init();
00354  mflavor=table.getFlavor();
00355  mdefaultFlavor = table.defaultFlavor();
00356  mprodTime = table.getProdTime();
00357 
00358  mschemaID = table.getSchemaID();
00359  mrows = table.GetNRows();
00360  mhasDescriptor=table.hasDescriptor();
00361  mdescriptor=table.getDescriptorCpy();
00362  
00363  mbeginTime.setDateTime(table.getBeginDateTime());
00364  mbeginTime.setUnixTime(table.getBeginTime());
00365  mendTime.setDateTime(table.getEndDateTime());
00366  mendTime.setUnixTime(table.getEndTime());
00367 
00368  char* tmp = table.GetTable();
00369  if(mrows==0) mrows = 1; 
00370  if(tmp) {
00371    unsigned int size =  mrows*table.getTableSize();
00372    mdata = new char[size];
00373    memcpy(mdata,tmp,size);
00374    mhasData = true;
00375  }
00376 
00377  setCstructName(table.printCstructName());
00378  setDataTable(table.printDataTable());
00379 
00380 }

virtual StDbTable::~StDbTable (   )  [inline, virtual]
 

Definition at line 210 of file StDbTable.h. 

00210                       {         if(melementID) delete [] melementID;
00211                                 if(mdescriptor)delete mdescriptor; 
00212                                 if(mdata) delete [] mdata; 
00213                                 if(mdataTable) delete [] mdataTable;
00214                                 if(mstructName) delete []  mstructName;
00215                                 if(melementName) delete [] melementName;
00216                                 if(mtimeVals) delete [] mtimeVals;
00217                                 if(mflavor) delete [] mflavor;
00218                        };

Member Function Documentation

void StDbTable::addNElements (  int *  elements,
int  newRows
)  [virtual]
 

Definition at line 730 of file StDbTable.cc. 

00730                                                  {
00731 
00732 
00733   if(!melementID) return;
00734 
00735   int i,j,k;
00736   k=mrows-newRows;
00737   if(k<0)return;
00738   j=0;
00739   for(i=k;i<mrows;i++){
00740     melementID[i]=elements[j]; 
00741     j++;
00742   }
00743 
00744 }

void StDbTable::addNRows (  int  newRows  )  [virtual]
 

Definition at line 689 of file StDbTable.cc. 

00689                               {
00690 
00691   if(!mdescriptor) return;
00692 
00693   int newRows = numRows+mrows;
00694   //unsigned int rowsize=mdescriptor->getTotalSizeInBytes();
00695   unsigned int rowsize;
00696   if(!mdescriptor->getTrowSize()) {
00697      rowsize=mdescriptor->getTotalSizeInBytes();
00698   }else{
00699       rowsize=mdescriptor->getTrowSize();
00700    }
00701   unsigned int len = newRows*rowsize;
00702   char* newData = new char[len]; 
00703   memset(newData,0,len);
00704   if(mdata)memcpy(newData,mdata,mrows*rowsize);
00705   char* p1 = newData;
00706   p1+=mrows*rowsize;
00707   memset(p1,0,numRows*rowsize);
00708   if(mdata)delete [] mdata;
00709   mdata=newData;
00710 
00711   resizeElementID(newRows);
00712 };

void StDbTable::AddRows (  char *  data,
int  nrows
)  [virtual]
 

Definition at line 512 of file StDbTable.cc. 

00512                                      { 
00513 
00514 char* tmpData = duplicateData();
00515 int len1 = mrows*getTableSize();
00516 int len2 = nrows*getTableSize();
00517 
00518 int newRows = nrows+mrows;
00519 if(mdata){
00520    delete [] mdata;
00521    mdata = 0;
00522  }
00523 
00524 createMemory(newRows);
00525 
00526 char* ptr= &mdata[0];
00527 memcpy(mdata,tmpData,len1);
00528 ptr+=len1;
00529 memcpy(ptr,c,len2);
00530 
00531 delete [] tmpData;
00532 mhasData=true;
00533 
00534 }

void StDbTable::addWrittenRows (  int *  dataID,
int  numRows,
bool  canRollBack = false
)  [virtual]
 

Definition at line 445 of file StDbTable.cc. 

00445                                                                    {
00446 
00447   for(int i=0; i<numRows; i++) mstoredData.addWrittenRow(dataID[i]);
00448   if(canRollBack)mcanRollBack=true;
00449 
00450 }

void StDbTable::checkDescriptor (   ) 
 

Definition at line 1367 of file StDbTable.cc. 

01367                           {
01368 
01369 int i = mdescriptor->getNumElements();
01370 unsigned int size = mdescriptor->getTotalSizeInBytes();
01371  cout <<"Descriptor for Table = " << mname<<endl;
01372  cout <<" number of elements = "<<i<< " with size = " << size << endl;
01373  for(int k=0; k<i;k++){
01374    cout <<"Name = " << mdescriptor->getElementName(k);
01375    cout <<" size = " << mdescriptor->getElementSize(k);
01376    cout <<" offset = " <<mdescriptor->getElementOffset(k);
01377    cout <<" type = " <<(int)mdescriptor->getElementType(k)<<endl;
01378  }
01379 }

void StDbTable::clearStoreInfo (   )  [virtual]
 

Definition at line 457 of file StDbTable.cc.

StDbTable * StDbTable::Clone (   )  [inline, virtual]
 

Definition at line 372 of file StDbTable.h. 

00372 {return (new StDbTable(*this));}

void StDbTable::commitData (   )  [virtual]
 

Definition at line 456 of file StDbTable.cc. 

00456 { mstoredData.commit(); }

bool StDbTable::createMemory (  int  nrows  )  [protected]
 

Definition at line 579 of file StDbTable.cc. 

00579                                  { 
00580  mrows = nrows;
00581  bool retVal = true;
00582  if(mrows==0) {
00583    if(mdata)delete [] mdata; 
00584    mdata=0;
00585    return retVal;
00586  }
00587 
00588 // mdescriptor->getNumElements();
00589 //if (mdescriptor) {
00590 //cout <<"**************CHECKIT************"<<endl;
00591 //} 
00592  if(mdescriptor && mdescriptor->getNumElements()>0){
00593     //     if(mrows==0) mrows = 1;
00594       //int len = mrows*mdescriptor->getTotalSizeInBytes();
00595      int len;
00596      if (!mdescriptor->getTrowSize()){
00597        len =  mrows*mdescriptor->getTotalSizeInBytes();
00598      }else{
00599       len = mrows*mdescriptor->getTrowSize();
00600      }
00601       if(len>0){
00602       if(mdata)delete [] mdata;
00603       mdata=new char[len];
00604       memset(mdata,0,len);
00605       int max = mdescriptor->getNumElements();
00606       char* name;
00607       StTypeE type;
00608       unsigned int length;
00609       char * ptr;
00610       for(int i=0; i<max;i++){
00611         getElementSpecs(i,ptr,name,length,type);
00612         if(type==Stchar)ptr='\0';
00613         delete [] name;
00614       }
00615      }
00616   } else {
00617     if(!mname){mname=mstrDup("Unknown");}
00618     retVal = false;
00619   }
00620 
00621 return retVal;
00622 }

bool StDbTable::createMemory (   )  [protected]
 

Definition at line 626 of file StDbTable.cc. 

00626                         {
00627   if(mdata)return true;
00628   if(mrows==0) mrows=1;
00629   return createMemory(mrows);
00630 }

void StDbTable::dbStreamer (  StDbBufferI *  buff,
bool  isReading
)  [virtual]
 

Definition at line 833 of file StDbTable.cc. 

00833                                                       {
00834 
00835 int max = mdescriptor->getNumElements();
00836 char* name;
00837 StTypeE type;
00838 unsigned int length;
00839 char* ptr;
00840 
00841   bool ClientMode;
00842   if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00843 
00844  if(createMemory() && mrowNumber < mrows){
00845 
00846  for(int i=0; i<max; i++){
00847     getElementSpecs(i,ptr,name,length,type);
00848     if(isReading){
00849      ReadElement(ptr,name,length,type,(StDbBuffer*)buff);
00850      } else {
00851      WriteElement(ptr,name,length,type,(StDbBuffer*)buff);
00852     }       
00853    delete [] name;
00854  }
00855 
00856   mrowNumber++;
00857   if(isReading)mhasData=true;
00858 
00859  } else {
00860    cerr << "dbStreamer:: more rows delivered than allocated " << endl;
00861  }
00862  if(!ClientMode)buff->SetStorageMode();  // reset to StorageMode
00863 }

void StDbTable::dbStreamer (  typeAcceptor *  accept,
bool  isReading
)  [virtual]
 

Definition at line 926 of file StDbTable.cc. 

00926                                                          {
00927 
00928 int max = mdescriptor->getNumElements();
00929 char* name;
00930 StTypeE type;
00931 unsigned int length;
00932 char* ptr;
00933 
00934  if(createMemory() && mrowNumber < mrows){
00935 
00936    if(isReading){
00937      for(int i=0; i<max; i++){
00938       getElementSpecs(i,ptr,name,length,type);
00939       PassInElement(ptr,name,length,type,accept);
00940       delete [] name;
00941      }
00942      mhasData=true;
00943    } else {
00944      for(int i=0; i<max; i++){
00945       getElementSpecs(i,ptr,name,length,type);
00946       PassOutElement(ptr,name,length,type,accept);
00947       delete [] name;
00948      }
00949    }
00950 
00951  mrowNumber++;
00952  }
00953 
00954 }

void StDbTable::dbStreamerWrite (  StDbBufferI *  buff  )  [virtual]
 

Definition at line 868 of file StDbTable.cc. 

00868                                            {
00869 
00870 int max = mdescriptor->getNumElements();
00871 char* name;
00872 StTypeE type;
00873 unsigned int length;
00874 char* ptr;
00875 
00876 //  bool ClientMode;
00877 //  if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00878 
00879 // if(createMemory() && mrowNumber < mrows){
00880 
00881  if(mrowNumber<mrows){
00882    for(int i=0; i<max; i++){
00883      getElementSpecs(i,ptr,name,length,type);
00884      WriteElement(ptr,name,length,type,(StDbBuffer*)buff);
00885      delete [] name;       
00886    }
00887   mrowNumber++;
00888  }
00889 }

void StDbTable::dbTableStreamer (  StDbBufferI *  buff,
const char *  name,
bool  isReading
)  [virtual]
 

Definition at line 894 of file StDbTable.cc. 

00894                                                                              {
00895 
00896 int max = mdescriptor->getNumElements();
00897 //int size = mdescriptor->getTotalSizeInBytes();
00898 StTypeE type = mdescriptor->getElementType(0);
00899 unsigned int length = (unsigned int) mrows*max;
00900 
00901 char* ptr;
00902 
00903   bool ClientMode;
00904   if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00905 
00906  if(createMemory() && mrowNumber < mrows){
00907 
00908    ptr = &mdata[0];
00909    //    getElementSpecs(i,ptr,name,length,type);
00910    if(isReading){
00911      ReadElement(ptr,(char *) name,length,type,(StDbBuffer*)buff);
00912    } else {
00913      WriteElement(ptr,(char *) name,length,type,(StDbBuffer*)buff);
00914    }       
00915   mrowNumber=mrows;
00916   if(isReading) mhasData=true;
00917  }
00918 
00919  if(!ClientMode)buff->SetStorageMode();  // reset to StorageMode
00920 }

bool StDbTable::defaultFlavor (   )  const [inline, virtual]
 

Definition at line 336 of file StDbTable.h. 

00336 {return mdefaultFlavor;}

char * StDbTable::duplicateData (   )  [protected]
 

Definition at line 565 of file StDbTable.cc. 

00565                          { 
00566 
00567  char* dup=0;
00568  int len1 = mrows*getTableSize();
00569  if(len1 !=0){
00570   dup=new char[len1];
00571   memcpy(dup,mdata,len1);
00572  }
00573 return dup;
00574 }

char * StDbTable::getBeginDateTime (   )  [inline, virtual]
 

Definition at line 344 of file StDbTable.h. 

00344 {return mbeginTime.mdateTime; }

unsigned int StDbTable::getBeginTime (   )  const [inline, virtual]
 

Definition at line 343 of file StDbTable.h. 

00343 {return mbeginTime.munixTime; }

char * StDbTable::getCstructName (   )  [virtual]
 

Definition at line 418 of file StDbTable.cc. 

00418 { return mstrDup(mstructName); }

char * StDbTable::getDataTable (   )  [virtual]
 

Definition at line 424 of file StDbTable.cc. 

00424 { return mstrDup(mdataTable); }

void * StDbTable::getDataValue (  const char *  name,
int  rowNumber = 0
)  [virtual]
 

Definition at line 538 of file StDbTable.cc. 

00538                                                       {
00539 
00540   void* retVal=0;
00541   int saveRowNum=mrowNumber;
00542   mrowNumber=rowNumber;
00543   int max = mdescriptor->getNumElements();
00544   char* ename=0;
00545   StTypeE type;
00546   unsigned int length;
00547   char * ptr;
00548 
00549   for(int i=0;i<max;i++){ 
00550     getElementSpecs(i,ptr,ename,length,type);
00551     if(strcmp(name,ename)==0)break;
00552     if(ename) delete [] ename;
00553     ename=0;
00554   }
00555 
00556   mrowNumber=saveRowNum;
00557   if(!ename) return retVal;
00558 
00559   delete [] ename;
00560   return (void*)ptr;
00561 }

StTableDescriptorI * StDbTable::getDescriptor (   )  [inline, virtual]
 

Definition at line 370 of file StDbTable.h. 

00370 { return mdescriptor; }

StTableDescriptorI * StDbTable::getDescriptorCpy (   )  const [virtual]
 

Definition at line 461 of file StDbTable.cc. 

00461 { return mdescriptor->getCpy(); }

int * StDbTable::getElementID (  int &  nrows  )  [inline, virtual]
 

Definition at line 351 of file StDbTable.h. 

00351 { nrows = mrows; return melementID; }

char * StDbTable::getElementName (   )  [virtual]
 

Definition at line 635 of file StDbTable.cc. 

00635 { return mstrDup(melementName); };

void StDbTable::getElementSpecs (  int  elementNum,
char *&  c,
char *&  name,
unsigned int &  length,
StTypeE &  type
)  [protected, virtual]
 

Definition at line 810 of file StDbTable.cc. 

00810                                                                                                    {
00811 
00812      int tRow = mdescriptor->getTrowSize();
00813     unsigned int tSize=mdescriptor->getTotalSizeInBytes();
00814     unsigned int rowIndex;
00815     if (!tRow) {
00816         rowIndex = ((unsigned int)mrowNumber)*tSize;
00817      }else{
00818         rowIndex = ((unsigned int)mrowNumber)*tRow;
00819      }
00820     int i = elementNum;
00821     c = &mdata[rowIndex];
00822     int current = mdescriptor->getElementOffset(i);
00823     c += current; // for(int k=0;k<current;k++)c++;
00824     name   = mdescriptor->getElementName(i);
00825     length = mdescriptor->getElementLength(i);;
00826     type   = mdescriptor->getElementType(i);
00827 
00828 return;
00829 }

char * StDbTable::getEndDateTime (   )  [inline, virtual]
 

Definition at line 340 of file StDbTable.h. 

00340 { return mendTime.mdateTime; }

char * StDbTable::getEndStoreDateTime (   )  [inline, virtual]
 

Definition at line 348 of file StDbTable.h. 

00348 { return mendStoreTime.mdateTime; }

unsigned int StDbTable::getEndStoreTime (   )  const [inline, virtual]
 

Definition at line 347 of file StDbTable.h. 

00347 { return mendStoreTime.munixTime; }

unsigned int StDbTable::getEndTime (   )  const [inline, virtual]
 

Definition at line 339 of file StDbTable.h. 

00339 {return mendTime.munixTime; }

char * StDbTable::getFlavor (   )  [virtual]
 

Definition at line 440 of file StDbTable.cc. 

00440 { return mstrDup(mflavor); }

unsigned int StDbTable::getMaxTime (   )  [inline, virtual]
 

Definition at line 362 of file StDbTable.h. 

00362                                            {
00363   unsigned int retVal=0;
00364   for(int i=0; i<mrows;i++)if(mtimeVals[i]>retVal)retVal=mtimeVals[i];
00365   return retVal;
00366 }

int StDbTable::GetNRows (   )  const [inline, virtual]
 

Definition at line 373 of file StDbTable.h. 

00373 { return mrows; }

unsigned int StDbTable::getProdTime (   )  [inline, virtual]
 

Definition at line 338 of file StDbTable.h. 

00338 { return mprodTime; }

int StDbTable::getRowID (  int  rowNumber  )  const [inline, virtual]
 

Definition at line 353 of file StDbTable.h. 

00353                                                   { 
00354   if(rowNumber<mrows)return melementID[rowNumber];
00355   return 0;
00356 }

int StDbTable::getRowLimit (   )  const [inline, virtual]
 

Definition at line 375 of file StDbTable.h. 

00375 { return mrowsRequested; };

int StDbTable::getSchemaID (   )  const [inline, virtual]
 

Definition at line 368 of file StDbTable.h. 

00368 { return mschemaID; }

char * StDbTable::GetTable (   )  [virtual]
 

Definition at line 476 of file StDbTable.cc. 

00476 { if(!mdata)createMemory(); return mdata;};

void * StDbTable::GetTableCpy (   )  [virtual]
 

Definition at line 480 of file StDbTable.cc. 

00480                        { 
00481 
00482 if(!mdata)return (void*)GetTable();
00483 
00484  int len =  mrows*getTableSize();
00485  char* c = (char*)calloc(mrows,getTableSize());
00486  memcpy(c,mdata,len);
00487 
00488 return (void*)c;
00489 };

unsigned int StDbTable::getTableSize (   )  const [inline, virtual]
 

Definition at line 328 of file StDbTable.h. 

00328                                                   { 
00329 if(mhasDescriptor && !mdescriptor->getTrowSize()) return mdescriptor->getTotalSizeInBytes();
00330 if(mhasDescriptor) return mdescriptor->getTrowSize();
00331 return 0;
00332 }

unsigned int * StDbTable::getTimeValues (   )  [inline, virtual]
 

Definition at line 357 of file StDbTable.h. 

00357 { return mtimeVals; }

int * StDbTable::getWrittenRows (  int &  numRows  )  [virtual]
 

Definition at line 453 of file StDbTable.cc. 

00453                                    { 
00454        return mstoredData.getDataIDs(nRows); 
00455 }

bool StDbTable::hasData (   )  const [inline, virtual]
 

Definition at line 377 of file StDbTable.h. 

00377 { return mhasData; };

bool StDbTable::hasDescriptor (   )  const [inline, virtual]
 

Definition at line 371 of file StDbTable.h. 

00371 { return mhasDescriptor; }

void StDbTable::init (   )  [protected]
 

Definition at line 382 of file StDbTable.cc. 

00382                      {
00383  mflavor            = 0;
00384  mstructName        = 0; 
00385  melementName       = 0;
00386  mdataTable         = 0; 
00387  melementID         = 0;
00388  mhasDescriptor     = false;
00389  mdescriptor        = 0; 
00390  mdata              = 0; 
00391  mhasData           = false; 
00392  mrowsRequested     = 0;
00393  mtimeVals          = 0;
00394  mendTime.munixTime = 0;
00395  mrows              = 0;
00396  mrowNumber         = 0;
00397  mprodTime          = StDbDefaults::Instance()->getProdTime();
00398  setDefaultFlavor();
00399  mschemaID = 0;
00400 
00401 }

bool StDbTable::IsBaseLine (   )  const [inline, virtual]
 

Definition at line 382 of file StDbTable.h. 

00382 { return mIsBaseLine; }

bool StDbTable::IsBinary (   )  const [inline, virtual]
 

Definition at line 381 of file StDbTable.h. 

00381 { return mIsBinary; }

bool StDbTable::IsIndexed (   )  const [inline, virtual]
 

Definition at line 383 of file StDbTable.h. 

00383 { return mIsIndexed; }

bool StDbTable::IsTable (   )  const [inline, virtual]
 

Reimplemented from StDbNode.

Definition at line 327 of file StDbTable.h. 

00327 { return true; };

void StDbTable::PassInElement (  char *  ptr,
char *  name,
int  length,
StTypeE  type,
typeAcceptor *  accept
)  [protected, virtual]
 

Definition at line 1160 of file StDbTable.cc. 

01160                                                                                           {
01161 
01162 
01163   switch (type) {
01164   case Stchar:
01165     {
01166     char* data;
01167     accept->pass(name,data,len);
01168     memcpy(ptr,data,len);
01169     delete [] data;
01170     break;
01171     }
01172   case Stuchar:
01173     {
01174      unsigned char* data; 
01175      accept->pass(name,data,len);
01176      memcpy(ptr,data,len);
01177      delete [] data;
01178      break;
01179     }
01180   case Stshort:
01181     {
01182      short* data; 
01183      accept->pass(name,data,len);
01184      memcpy(ptr,data,len*sizeof(short));
01185      delete [] data;
01186      break;
01187     }
01188   case Stushort:
01189     {
01190      unsigned short* data; 
01191      accept->pass(name,data,len);
01192      memcpy(ptr,data,len*sizeof(short));
01193      delete [] data;
01194      break;
01195     }
01196   case Stint:
01197     {
01198      int* data; 
01199      accept->pass(name,data,len);
01200      memcpy(ptr,data,len*sizeof(int));
01201      delete [] data;
01202      break;
01203     }
01204   case Stuint:
01205     {
01206      unsigned int* data; 
01207      accept->pass(name,data,len);
01208      memcpy(ptr,data,len*sizeof(int));
01209      delete [] data;
01210      break;
01211     }
01212   case Stlong:
01213     {
01214      long* data; 
01215      accept->pass(name,data,len);
01216      memcpy(ptr,data,len*sizeof(long));
01217      delete [] data;
01218      break;
01219     }
01220   case Stulong:
01221     {
01222      unsigned long* data; 
01223      accept->pass(name,data,len);
01224      memcpy(ptr,data,len*sizeof(long));
01225      delete [] data;
01226      break;
01227     }
01228   case Stlonglong:
01229     {
01230      long long* data; 
01231      accept->pass(name,data,len);
01232      memcpy(ptr,data,len*sizeof(long long));
01233      delete [] data;
01234      break;
01235     }
01236   case Stfloat:
01237     {
01238      float* data; 
01239      accept->pass(name,data,len);
01240      memcpy(ptr,data,len*sizeof(float));
01241      delete [] data;
01242      break;
01243     }
01244   case Stdouble:
01245     {
01246      double* data; 
01247      accept->pass(name,data,len);
01248      memcpy(ptr,data,len*sizeof(double));
01249      delete [] data;
01250      break;
01251     }
01252   }
01253 }

void StDbTable::PassOutElement (  char *  ptr,
char *  name,
int  length,
StTypeE  type,
typeAcceptor *  accept
)  [protected, virtual]
 

Definition at line 1258 of file StDbTable.cc. 

01258                                                                                            {
01259 
01260   switch (type) {
01261   case Stchar:
01262     {
01263     accept->pass(name,ptr,len);
01264     break;
01265     }
01266   case Stuchar:
01267     {
01268      unsigned char* muchar = (unsigned char*)ptr;
01269      accept->pass(name, muchar,len);
01270     break;
01271     }
01272   case Stshort:
01273     {
01274     short* mshort = (short*)ptr;
01275     if(len==1){
01276       accept->pass(name, *mshort ,len);
01277     } else {
01278       accept->pass(name,mshort,len);
01279     }
01280     break;
01281     }
01282   case Stushort:
01283     {
01284     unsigned short* mushort = (unsigned short*)ptr;
01285     if(len==1){
01286       accept->pass(name, *mushort ,len);
01287     } else {
01288       accept->pass(name,mushort,len);
01289     }
01290     break;
01291     }
01292   case Stint:
01293     {
01294     int* mint = (int*)ptr;
01295     if(len==1){
01296       accept->pass(name, *mint ,len);
01297     } else {
01298       accept->pass(name,mint,len);
01299     }
01300     break;
01301     }
01302   case Stuint:
01303     {
01304     unsigned int* muint = (unsigned int*)ptr;
01305     if(len==1){
01306       accept->pass(name, *muint ,len);
01307     } else {
01308       accept->pass(name,muint,len);
01309     }
01310     break;
01311     }
01312   case Stlong:
01313     {
01314     long* mlong = (long*)ptr;
01315     if(len==1){
01316       accept->pass(name, *mlong ,len);
01317     } else {
01318       accept->pass(name,mlong,len);
01319     }
01320     break;
01321     }
01322   case Stulong:
01323     {
01324     unsigned long* mulong = (unsigned long*)ptr;
01325     if(len==1){
01326       accept->pass(name, *mulong ,len);
01327     } else {
01328       accept->pass(name,mulong,len);
01329     }
01330     break;
01331     }
01332   case Stlonglong:
01333     {
01334     long long* mlonglong = (long long*)ptr;
01335     if(len==1){
01336       accept->pass(name, *mlonglong ,len);
01337     } else {
01338       accept->pass(name,mlonglong,len);
01339     }
01340     break;
01341     }
01342   case Stfloat:
01343     {
01344     float* mfloat = (float*)ptr;
01345     if(len==1){
01346       accept->pass(name, *mfloat ,len);
01347     } else {
01348       accept->pass(name,mfloat,len);
01349     }
01350     break;
01351     }
01352   case Stdouble:
01353     {
01354     double* mdouble = (double*)ptr;
01355     if(len==1){
01356       accept->pass(name, *mdouble ,len);
01357     } else {
01358       accept->pass(name,mdouble,len);
01359     }
01360     break;
01361     }
01362   }
01363 }

char * StDbTable::printCstructName (   )  [inline, virtual]
 

Definition at line 333 of file StDbTable.h. 

00333 { return mstructName; }

char * StDbTable::printDataTable (   )  [inline, virtual]
 

Definition at line 334 of file StDbTable.h. 

00334 { return mdataTable; }

char * StDbTable::printElementName (   )  [inline, virtual]
 

Definition at line 367 of file StDbTable.h. 

00367 { return melementName; }

char * StDbTable::printFlavor (   )  [inline, virtual]
 

Definition at line 335 of file StDbTable.h. 

00335 { return mflavor; }

void StDbTable::printNoDataReturned (  const char *  elementName  )  [protected]
 

Definition at line 1382 of file StDbTable.cc. 

01382                                                           {
01383 
01384   StString emess;
01385   emess<<" No data return from table="<<printName()<<" column="<<elementName;
01386   StDbManager::Instance()->printInfo((emess.str()).c_str(),dbMWarn,__LINE__,__CLASS__,"ReadElement(ptr,name,len,type,buffer)");
01387 }

void StDbTable::ReadElement (  char *&  ptr,
char *  name,
int  length,
StTypeE  type,
StDbBuffer *  buff
)  [protected, virtual]
 

Definition at line 959 of file StDbTable.cc. 

00959                                                                                      {
00960 
00961 char* mchar; unsigned char* muchar; short* mshort; unsigned short* mushort; 
00962 int* mint; unsigned int* muint; long* mlong; unsigned long* mulong; 
00963 long long* mlonglong;
00964 float* mfloat; double* mdouble;
00965 
00966  int blen; // length returned from db  ### use lesser of len & blen 
00967  
00968   switch (type) {
00969   case Stchar:
00970     {
00971         StString cn;
00972         cn<<name<<".text"; const char* commentName = (cn.str()).c_str();
00973         mchar = 0;
00974         if(!buff->ReadScalar(mchar,commentName))buff->ReadScalar(mchar,name);
00975         if(mchar){
00976              int len1=strlen(mchar);
00977              if(len>len1) len=len1;
00978              strncpy(ptr,mchar,len);
00979              delete [] mchar;
00980         } else {
00981              *ptr='\0';
00982              printNoDataReturned(name);
00983         }
00984     break;
00985     }
00986   case Stuchar:
00987     {
00988       if(buff->ReadArray(muchar,blen,name)){
00989         if(len>blen)len=blen;
00990         memcpy(ptr,muchar,len*sizeof(unsigned char));
00991         delete [] muchar;
00992       } else { printNoDataReturned(name); }
00993     break;
00994     }
00995   case Stshort:
00996     {
00997       if(buff->ReadArray(mshort,blen,name)){
00998         if(len>blen)len=blen;
00999         memcpy(ptr,mshort,len*sizeof(short));
01000         delete [] mshort;
01001       } else { printNoDataReturned(name); }
01002     break;
01003     }
01004   case Stushort:
01005     {
01006       if(buff->ReadArray(mushort,blen,name)){
01007         if(len>blen)len=blen;
01008         memcpy(ptr,mushort,len*sizeof(unsigned short));
01009         delete [] mushort;
01010       } else { printNoDataReturned(name); }
01011     break;
01012     }
01013   case Stint:
01014     {
01015       if(buff->ReadArray(mint,blen,name)){
01016         if(len>blen)len=blen;
01017          memcpy(ptr,mint,len*sizeof(int));
01018          delete [] mint;
01019       } else { printNoDataReturned(name); }
01020     break;
01021     }
01022   case Stuint:
01023     {
01024       if(buff->ReadArray(muint,blen,name)){
01025         if(len>blen)len=blen;
01026        memcpy(ptr,muint,len*sizeof(unsigned int));
01027        delete [] muint;
01028       } else { printNoDataReturned(name); }
01029     break;
01030     }
01031   case Stlong:
01032     {
01033       if(buff->ReadArray(mlong,blen,name)){
01034         if(len>blen)len=blen;
01035        memcpy(ptr,mlong,len*sizeof(long));
01036        delete [] mlong;
01037       } else { printNoDataReturned(name); }
01038     break;
01039     }
01040   case Stulong:
01041     {
01042       if(buff->ReadArray(mulong,blen,name)){
01043         if(len>blen)len=blen;
01044        memcpy(ptr,mulong,len*sizeof(unsigned long));
01045        delete [] mulong;
01046       } else { printNoDataReturned(name); }
01047     break;
01048     }
01049   case Stlonglong:
01050     {
01051       if(buff->ReadArray(mlonglong,blen,name)){
01052         if(len>blen)len=blen;
01053        memcpy(ptr,mlonglong,len*sizeof(long long));
01054        delete [] mlonglong;
01055       } else { printNoDataReturned(name); }
01056     break;
01057     }
01058   case Stfloat:
01059     {
01060       if(buff->ReadArray(mfloat,blen,name)){
01061        if(len>blen)len=blen;
01062        memcpy(ptr,mfloat,len*sizeof(float));
01063        delete [] mfloat;
01064       } else { printNoDataReturned(name); }
01065     break;
01066     }
01067   case Stdouble:
01068     {
01069       if(buff->ReadArray(mdouble,blen,name)){
01070        if(len>blen)len=blen;
01071        memcpy(ptr,mdouble,len*sizeof(double));
01072        delete [] mdouble;
01073       } else { printNoDataReturned(name); }
01074     break;
01075     }
01076   }
01077 
01078 }

void StDbTable::resizeElementID (  int  numRows  )  [virtual]
 

Definition at line 716 of file StDbTable.cc. 

00716                                      {
00717 
00718   int * newElements=new int[numRows];
00719   if(melementID) {
00720     memcpy(newElements,melementID,mrows*sizeof(int));
00721     delete [] melementID;
00722   }
00723   melementID=newElements;
00724   mrows = numRows;
00725 
00726 };

void StDbTable::resizeNumRows (  int  nrows  )  [virtual]
 

Definition at line 655 of file StDbTable.cc. 

00655                                       {
00656   // if only some rows are returned, this is called to
00657   // compress memory
00658 
00659   //unsigned int rowsize=mdescriptor->getTotalSizeInBytes();
00660   unsigned int rowsize;
00661   if (!mdescriptor->getTrowSize()) {
00662      rowsize=mdescriptor->getTotalSizeInBytes();
00663   }else{
00664       rowsize=mdescriptor->getTrowSize();
00665    }
00666   unsigned int len = mrows*rowsize;
00667   unsigned int newlen = nrows*rowsize;
00668 
00669   if(mdata){
00670     char* oldData=new char[len];
00671     memcpy(oldData,mdata,len);
00672     delete [] mdata;
00673     mdata = new char[newlen];
00674     if(newlen<=len){
00675       memcpy(mdata,oldData,newlen);
00676     } else {
00677       memcpy(mdata,oldData,len);
00678     }
00679     delete [] oldData;
00680   }
00681 
00682   mrows=nrows;
00683   return;
00684 }

void StDbTable::setBaseLine (  bool  baseLine  )  [inline, virtual]
 

Definition at line 379 of file StDbTable.h. 

00379 { mIsBaseLine=baseLine; }

void StDbTable::setBeginTime (  const char *  time  )  [inline, virtual]
 

Definition at line 346 of file StDbTable.h. 

00346 { mbeginTime.setDateTime(time); }

void StDbTable::setBeginTime (  unsigned int  time  )  [inline, virtual]
 

Definition at line 345 of file StDbTable.h. 

00345 {mbeginTime.munixTime = time; }

void StDbTable::setBinary (  bool  abinary  )  [inline, virtual]
 

Definition at line 378 of file StDbTable.h. 

00378 { mIsBinary=abinary; }

void StDbTable::setCstructName (  const char *  name  )  [virtual]
 

Definition at line 415 of file StDbTable.cc. 

00415 { mstructName=mstrDup(name); }

void StDbTable::setDataTable (  const char *  name  )  [virtual]
 

Definition at line 421 of file StDbTable.cc. 

00421 { mdataTable=mstrDup(name); }

void StDbTable::setDefaultFlavor (   )  [virtual]
 

Definition at line 428 of file StDbTable.cc. 

00428                            { setFlavor(StDbDefaults::Instance()->printFlavor());
00429 }

void StDbTable::setDescriptor (  StTableDescriptorI *  descriptor  )  [virtual]
 

Definition at line 465 of file StDbTable.cc. 

00465                                                       { 
00466 
00467  if(mdescriptor) delete mdescriptor;
00468  mdescriptor=descriptor;
00469  mhasDescriptor=true;
00470  
00471  //checkDescriptor();
00472 
00473 };

void StDbTable::setElementID (  int *  elements,
int  nrows
)  [virtual]
 

Definition at line 641 of file StDbTable.cc. 

00641                                                 { 
00642 
00643    createMemory(nrows);
00644    // set up & fill char* will element list
00645    if(melementID) delete [] melementID;
00646    if(nrows==0){
00647      melementID=0;
00648      return;
00649    }
00650    melementID = new int[nrows];
00651    memcpy(melementID, elements, nrows*sizeof(int));
00652 }

void StDbTable::setElementName (  const char *  ename  )  [virtual]
 

Definition at line 638 of file StDbTable.cc. 

00638 { melementName=mstrDup(name);};

void StDbTable::setEndStoreTime (  const char *  time  )  [inline, virtual]
 

Definition at line 350 of file StDbTable.h. 

00350 { mendStoreTime.setDateTime(time); }

void StDbTable::setEndStoreTime (  unsigned int  time  )  [inline, virtual]
 

Definition at line 349 of file StDbTable.h. 

00349 {mendStoreTime.munixTime = time; }

void StDbTable::setEndTime (  const char *  time  )  [inline, virtual]
 

Definition at line 342 of file StDbTable.h. 

00342 {mendTime.setDateTime(time);}

void StDbTable::setEndTime (  unsigned int  time  )  [inline, virtual]
 

Definition at line 341 of file StDbTable.h. 

00341 { mendTime.munixTime=time;}

void StDbTable::setFlavor (  const char *  flavor  )  [virtual]
 

Definition at line 432 of file StDbTable.cc. 

00432                                              { 
00433   if(!flavor) return;
00434   if(mflavor) delete [] mflavor;
00435   mflavor=new char[strlen(flavor)+1];
00436   strcpy(mflavor,flavor);  
00437   mdefaultFlavor = StDbDefaults::Instance()->IsDefaultFlavor(mflavor);
00438 }

void StDbTable::setIndexed (  bool  indexed  )  [inline, virtual]
 

Definition at line 380 of file StDbTable.h. 

00380 { mIsIndexed=indexed; }

void StDbTable::setNodeInfo (  StDbNode *  node  )  [virtual]
 

Definition at line 404 of file StDbTable.cc. 

00404                                          {
00405 
00406     mdbType=node->getDbType();
00407     mdbDomain=node->getDbDomain();
00408     setDbName(node->printDbName());
00409     setVersion(node->printVersion());
00410     setNodeType(node->printNodeType());
00411     mnodeID=node->getNodeID();
00412 };

void StDbTable::setProdTime (  unsigned int  ptime  )  [inline, virtual]
 

Definition at line 337 of file StDbTable.h. 

00337 { mprodTime=ptime; }

void StDbTable::setRowLimit (  int  nrows  )  [inline, virtual]
 

Definition at line 374 of file StDbTable.h. 

00374 { mrowsRequested=nrows; };

void StDbTable::setRowNumber (  int  row = 0  )  [inline, virtual]
 

Definition at line 376 of file StDbTable.h. 

00376 {if(row < mrows)mrowNumber = row;}

void StDbTable::setSchemaID (  int  id  )  [inline, virtual]
 

Definition at line 369 of file StDbTable.h. 

00369 {mschemaID = id; }

void StDbTable::SetTable (  char *  data,
int  nrows,
int *  idList = 0
)  [virtual]
 

calloc'd version of data for StRoot

Definition at line 493 of file StDbTable.cc. 

00493                                                    { 
00494 
00495 if(mdata){
00496   delete [] mdata; 
00497   mdata = 0;
00498 }
00499  if(!idList){
00500    createMemory(nrows);
00501  } else {
00502    setElementID(idList,nrows); // createMemory is called here
00503  }
00504 int len = nrows*getTableSize();
00505 memcpy(mdata,c,len);
00506 mhasData=true;
00507 
00508 }

void StDbTable::setTimeValues (  unsigned int *  timeValues  )  [inline, virtual]
 

Definition at line 358 of file StDbTable.h. 

00358                                                                      { 
00359   if(mtimeVals) delete [] mtimeVals;
00360   mtimeVals=timeValues;
00361 }

void StDbTable::StreamAccessor (  StDbBufferI *  buff,
bool  isReading
)  [virtual]
 

Definition at line 770 of file StDbTable.cc. 

00770                                                           {
00771 
00772   bool ClientMode;
00773   if(!(ClientMode=buff->IsClientMode()))buff->SetClientMode();
00774 
00775   int rowID;
00776   if(!melementID){
00777      melementID = new int[mrows];
00778      for(int i=0;i<mrows;i++)melementID[i]=i;
00779   }
00780 
00781   if(isReading){
00782     buff->ReadScalar(rowID,"elementID");
00783     melementID[mrowNumber]=rowID;
00784 
00785     if(mrowNumber==0){
00786      buff->ReadScalar(mschemaID,"schemaID");
00787      if(mversion) delete [] mversion;
00788      buff->ReadScalar(mversion,"version");
00789     } else {
00790       unsigned int bTime;// , eTime;
00791       buff->ReadScalar(bTime,"beginTime"); 
00792       if(bTime>mbeginTime.munixTime)mbeginTime.munixTime=bTime;
00793     }
00794 
00795   } else {
00796 
00797    buff->WriteScalar(mschemaID,"schemaID");
00798    buff->WriteScalar(mbeginTime.munixTime,"beginTime");
00799    if(mversion)buff->WriteScalar(mversion,"version");
00800    rowID = melementID[mrowNumber];   
00801    buff->WriteScalar(rowID,"elementID");
00802   }
00803 
00804  if(!ClientMode)buff->SetStorageMode();  // reset to StorageMode
00805 
00806 }

void StDbTable::StreamAccessor (  typeAcceptor *  accept,
bool  isReading
)  [virtual]
 

Definition at line 748 of file StDbTable.cc. 

00748                                                              {
00749 
00750    int len = 1;
00751    accept->pass((char*)"schemaID",mschemaID,len);
00752 
00753    if(isReading){
00754      if(mbeginTime.mdateTime) delete [] mbeginTime.mdateTime;
00755      if(mversion)delete [] mversion;
00756      if(melementID)delete [] melementID;
00757    } else {
00758      if(!melementID){
00759        melementID = new int[mrows];
00760        for(int i=0;i<mrows;i++)melementID[i]=i;
00761      }
00762    }
00763    accept->pass((char*)"beginTime",mbeginTime.mdateTime,len);
00764    accept->pass((char*)"version",mversion,len);
00765    accept->pass((char*)"elementID",melementID, mrows);
00766 }

void StDbTable::WriteElement (  char *  ptr,
char *  name,
int  length,
StTypeE  type,
StDbBuffer *  buff
)  [protected, virtual]
 

Definition at line 1083 of file StDbTable.cc. 

01083                                                                                      {
01084 
01085   switch (type) {
01086   case Stchar:
01087     {
01088     char* mchar = ptr;
01089     buff->WriteScalar(mchar,name);
01090     break;
01091     }
01092   case Stuchar:
01093     {
01094     unsigned char* muchar = (unsigned char*)ptr;
01095     buff->WriteArray(muchar,len,name);
01096     break;
01097     }
01098   case Stshort:
01099     {
01100     short* mshort = (short*) ptr;
01101     buff->WriteArray(mshort ,len,name);
01102     break;
01103     }
01104   case Stushort:
01105     {
01106     unsigned short* mushort = (unsigned short*) ptr;
01107     buff->WriteArray(mushort,len,name);
01108     break;
01109     }
01110   case Stint:
01111     {
01112     int* mint = (int*)ptr;
01113     buff->WriteArray(mint,len,name);
01114     break;
01115     }
01116   case Stuint:
01117     {
01118     unsigned int* muint = (unsigned int*) ptr;
01119     buff->WriteArray(muint,len,name);
01120     break;
01121     }
01122   case Stlong:
01123     {
01124     long* mlong = (long*) ptr;
01125     //if(len==1) cout << name << " = "<< *mlong << endl;
01126     buff->WriteArray(mlong,len,name);
01127     break;
01128     }
01129   case Stulong:
01130     {
01131     unsigned long* mulong = (unsigned long*) ptr;
01132     buff->WriteArray(mulong,len,name);
01133     break;
01134     }
01135   case Stlonglong:
01136     {
01137     long long* mlonglong = (long long*) ptr;
01138     buff->WriteArray(mlonglong,len,name);
01139     break;
01140     }
01141   case Stfloat:
01142     {
01143     float* mfloat = (float*) ptr;
01144     //if(len==1) cout << name << " = "<< *mfloat << endl;
01145     buff->WriteArray(mfloat,len,name);
01146     break;
01147     }
01148   case Stdouble:
01149     {
01150     double* mdouble = (double*) ptr;
01151     buff->WriteArray(mdouble,len,name);
01152     break;
01153     }
01154   }
01155 
01156 }

Member Data Documentation

StDbTime StDbTable::mbeginTime [protected]
 

validity interval

Definition at line 161 of file StDbTable.h.

char* StDbTable::mdata [protected]
 

data & num of rows

Definition at line 184 of file StDbTable.h.

char* StDbTable::mdataTable [protected]
 

Definition at line 171 of file StDbTable.h.

bool StDbTable::mdefaultFlavor [protected]
 

Definition at line 157 of file StDbTable.h.

StTableDescriptorI* StDbTable::mdescriptor [protected]
 

Definition at line 181 of file StDbTable.h.

int* StDbTable::melementID [protected]
 

Definition at line 174 of file StDbTable.h.

char* StDbTable::melementName [protected]
 

Definition at line 167 of file StDbTable.h.

StDbTime StDbTable::mendStoreTime [protected]
 

Definition at line 163 of file StDbTable.h.

StDbTime StDbTable::mendTime [protected]
 

Definition at line 162 of file StDbTable.h.

char* StDbTable::mflavor [protected]
 

Definition at line 156 of file StDbTable.h.

bool StDbTable::mhasData [protected]
 

Definition at line 187 of file StDbTable.h.

bool StDbTable::mhasDescriptor [protected]
 

c-struct descriptor information

Definition at line 180 of file StDbTable.h.

bool StDbTable::mIsBaseLine [protected]
 

Definition at line 168 of file StDbTable.h.

bool StDbTable::mIsBinary [protected]
 

Definition at line 169 of file StDbTable.h.

bool StDbTable::mIsIndexed [protected]
 

Definition at line 170 of file StDbTable.h.

unsigned int StDbTable::mprodTime [protected]
 

Definition at line 158 of file StDbTable.h.

int StDbTable::mrowNumber [protected]
 

Definition at line 186 of file StDbTable.h.

int StDbTable::mrows [protected]
 

Definition at line 185 of file StDbTable.h.

int StDbTable::mrowsRequested [protected]
 

Definition at line 188 of file StDbTable.h.

int StDbTable::mschemaID [protected]
 

Definition at line 173 of file StDbTable.h.

StDbStoreInfo StDbTable::mstoredData [protected]
 

for rolling back stores

Definition at line 177 of file StDbTable.h.

char* StDbTable::mstructName [protected]
 

Definition at line 166 of file StDbTable.h.

unsigned int* StDbTable::mtimeVals [protected]
 

Definition at line 189 of file StDbTable.h.

The documentation for this class was generated from the following files:
Generated on Thu Aug 24 14:46:05 2006 for Doxygen by doxygen 1.3.7