ROOT logo
// @(#)root/table:$Id$
// Author: Valery Fine(fine@mail.cern.ch)   03/07/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TTable
#define ROOT_TTable

//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TTable                                                              //
//                                                                      //
//  It is a base class to create a "wrapper" class                      //
//  holding the plain C-structure array                                 //
//  (1 element of the structure per element)                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifdef __CINT__
#pragma Ccomment on
#endif

#include "Ttypes.h"
#include "TDataSet.h"
#include "tableDescriptor.h"
#ifndef ROOT_TCut
# include "TCut.h"
#endif

# ifndef ROOT_Riosfwd
#  include "Riosfwd.h"
# endif

#ifndef __CINT__
#  include <string.h>
#  include <assert.h>
#endif

#include <vector>

class TTableDescriptor;
class TH1;
class TTableMap;
typedef TTableMap*  Ptr_t;

class TTable : public TDataSet {
   friend class TDataSet;
   friend class St_XDFFile;
protected:
   Long_t     fSize;       // Size of the one element (row) of the table

protected:

   Int_t      fN;           //Number of array elements
   Char_t    *fTable;       // Array of (fN*fSize) longs
   Long_t     fMaxIndex;    // The used capacity of this array

   Bool_t    BoundsOk(const char *where, Int_t at) const;
   Bool_t    OutOfBoundsError(const char *where, Int_t i) const;

   void       CopyStruct(Char_t *dest, const Char_t *src);
   Char_t    *Create();
   virtual    void       Clear(Option_t *opt="");
   virtual    void       Delete(Option_t *opt="");
   virtual Bool_t  EntryLoop(const Char_t *exprFileName,Int_t &action, TObject *obj, Int_t nentries=1000000000, Int_t firstentry=0, Option_t *option="");
   Int_t      SetfN(Long_t len);
   void       SetTablePointer(void *table);
   void       SetUsedRows(Int_t n);
   virtual void SetType(const char *const type);
   void       StreamerHeader(TBuffer &b,Version_t version=3);
   void       StreamerTable(TBuffer &b,Version_t version=3);
   virtual TTableDescriptor *GetDescriptorPointer() const;
   virtual void  SetDescriptorPointer(TTableDescriptor *list);

   void       ReAlloc(Int_t newsize);
   static const char *TableDictionary(const char *className,const char *structName,TTableDescriptor *&ColDescriptors);

public:

   enum EColumnType {kNAN, kFloat, kInt, kLong, kShort, kDouble, kUInt
                     ,kULong, kUShort, kUChar, kChar, kPtr, kBool
                     ,kEndColumnType };
   enum ETableBits {
      kIsNotOwn      = BIT(23)   // if the TTable wrapper doesn't own the STAF table
                                 // As result of the Update() method for example
   };
   static const char *fgTypeName[kEndColumnType];
   TTable(const char *name=0, Int_t size=0);
   TTable(const char *name, Int_t n,Int_t size);
   TTable(const char *name, Int_t n, Char_t *array,Int_t size);
   TTable(const char *name, const char *type, Int_t n, Char_t *array, Int_t size);
   TTable(const TTable &table);
   TTable    &operator=(const TTable &rhs);
   virtual    ~TTable();

   virtual     void       Adopt(Int_t n, void *array);
   virtual     Int_t      AddAt(const void *c);
   virtual     void       AddAt(const void *c, Int_t i);
   virtual     void       AddAt(TDataSet *dataset,Int_t idx=0);
   virtual     Long_t     AppendRows(const void *row, UInt_t nRows);
   virtual     void       AsString(void *buf, EColumnType type, Int_t width, ostream &out) const;
              const void *At(Int_t i) const;
   virtual     void       Browse(TBrowser *b);
   virtual     void       CopySet(TTable &array);
               Int_t      CopyRows(const TTable *srcTable,Long_t srcRow=0, Long_t dstRow=0, Long_t nRows=0, Bool_t expand=kFALSE);
   virtual     void       DeleteRows(Long_t indx,UInt_t nRows=1);
   virtual     void       Draw(Option_t *opt);
   virtual     TH1       *Draw(TCut varexp, TCut selection, Option_t *option=""
                         ,Int_t nentries=1000000000, Int_t firstentry=0);
   virtual     TH1       *Draw(const char *varexp, const char *selection, Option_t *option=""
                              ,Int_t nentries=1000000000, Int_t firstentry=0); // *MENU*
               void      *GetArray()     const ;
   virtual     TClass    *GetRowClass()  const ;
               Int_t      GetSize() const { return fN; }
   virtual     Long_t     GetNRows()     const;
   virtual     Long_t     GetRowSize()   const;
   virtual     Long_t     GetTableSize() const;
   virtual     TTableDescriptor *GetTableDescriptors() const;
   virtual     TTableDescriptor *GetRowDescriptors()   const;
   virtual     const Char_t *GetType()   const;
   virtual     void       Fit(const char *formula ,const char *varexp, const char *selection="",Option_t *option="" ,Option_t *goption=""
                              ,Int_t nentries=1000000000, Int_t firstentry=0); // *MENU*

   virtual     Long_t     HasData() const { return 1; }
   virtual     Long_t     InsertRows(const void *rows, Long_t indx, UInt_t nRows=1);
   virtual     Bool_t     IsFolder() const;
               Int_t      NaN();
   static      TTable    *New(const Char_t *name, const Char_t *type, void *array, UInt_t size);
   virtual     Char_t    *MakeExpression(const Char_t *expressions[],Int_t nExpressions);
   virtual     Char_t    *Print(Char_t *buf,Int_t n) const ;
   virtual     void       Print(Option_t *opt="") const;
   virtual  const Char_t *Print(Int_t row, Int_t rownumber=10,
                                const Char_t *colfirst="", const Char_t *collast="") const; // *MENU*
   virtual     void       PrintContents(Option_t *opt="") const;
   virtual  const Char_t *PrintHeader() const; // *MENU*
   virtual     void       Project(const char *hname, const char *varexp, const char *selection="", Option_t *option=""
                                 ,Int_t nentries=1000000000, Int_t firstentry=0);

   virtual    Int_t       Purge(Option_t *opt="");

               void      *ReAllocate(Int_t newsize);
               void      *ReAllocate();
   virtual     void       SavePrimitive(ostream &out, Option_t *option = "");
   virtual     void       Set(Int_t n);
   virtual     void       Set(Int_t n, Char_t *array);
   virtual     void       SetNRows(Int_t n);
   virtual     void       Reset(Int_t c=0);
   virtual     void       ResetMap(Bool_t wipe=kTRUE);
   virtual     void       Update();
   virtual     void       Update(TDataSet *set,UInt_t opt=0);
               void      *operator[](Int_t i);
               const void *operator[](Int_t i) const;


 //  ----   Table descriptor service   ------

   virtual   Int_t        GetColumnIndex(const Char_t *columnName) const;
   virtual  const Char_t *GetColumnName(Int_t columnIndex)      const;
   virtual  const UInt_t *GetIndexArray(Int_t columnIndex)      const;
   virtual  UInt_t        GetNumberOfColumns()                  const;
   virtual  UInt_t        GetOffset(Int_t columnIndex)          const;
   virtual  Int_t         GetOffset(const Char_t *columnName=0) const;
   virtual  UInt_t        GetColumnSize(Int_t columnIndex)      const;
   virtual  Int_t         GetColumnSize(const Char_t *columnName=0) const;
   virtual  UInt_t        GetTypeSize(Int_t columnIndex)        const;
   virtual  Int_t         GetTypeSize(const Char_t *columnName=0) const ;
   virtual  UInt_t        GetDimensions(Int_t columnIndex)      const;
   virtual  Int_t         GetDimensions(const Char_t *columnName=0) const ;
   virtual  EColumnType   GetColumnType(Int_t columnIndex)      const;
   virtual  EColumnType   GetColumnType(const Char_t *columnName=0) const;
   virtual  const Char_t *GetColumnComment(Int_t columnIndex) const;

   static const char *GetTypeName(EColumnType type);
   static EColumnType GetTypeId(const char *typeName);

   // Table index iterator:
   class iterator {
      public:
         typedef std::vector<Long_t>::iterator vec_iterator;
         typedef std::vector<Long_t>::const_iterator vec_const_iterator;
      private:
         Long_t        fRowSize;
         const TTable *fThisTable;
         vec_iterator  fCurrentRow;
      public:
         iterator(): fRowSize(0), fThisTable(0) {;}
         iterator(const TTable &table, vec_iterator &arowPtr) :
            fRowSize(table.GetRowSize()), fThisTable(&table), fCurrentRow(arowPtr) {;}
         iterator(const TTable &table, vec_const_iterator &arowPtr) :
            fRowSize(table.GetRowSize()), fThisTable(&table),
            fCurrentRow(*(std::vector<Long_t>::iterator *)(void *)&arowPtr) {;}
            //fCurrentRow(* const_cast<vector<Long_t>::iterator *>(&arowPtr) ) {;}
         iterator(const iterator& iter) : fRowSize (iter.fRowSize), fThisTable(iter.fThisTable),fCurrentRow(iter.fCurrentRow){}
         iterator &operator=(const iterator& iter)   { fRowSize = iter.fRowSize; fThisTable = iter.fThisTable; fCurrentRow=iter.fCurrentRow; return *this; }
         void operator++()    { ++fCurrentRow;   }
         void operator++(int) {   fCurrentRow++; }
         void operator--()    { --fCurrentRow;   }
         void operator--(int) {   fCurrentRow--; }
         iterator operator+(Int_t idx)   { std::vector<Long_t>::iterator addition   = fCurrentRow+idx; return  iterator(*fThisTable,addition); }
         iterator operator-(Int_t idx)   { std::vector<Long_t>::iterator subtraction = fCurrentRow-idx; return  iterator(*fThisTable,subtraction); }
         void operator+=(Int_t idx)  {  fCurrentRow+=idx; }
         void operator-=(Int_t idx)  {  fCurrentRow-=idx; }
         void *rowPtr() const { return  (void *)(((const char *)fThisTable->GetArray()) + (*fCurrentRow)*fRowSize ); }
         operator void *() const { return rowPtr(); }
         Int_t operator-(const iterator &it) const { return (*fCurrentRow)-(*(it.fCurrentRow)); }
         Long_t operator *() const { return  *fCurrentRow; }
         Bool_t operator==(const iterator &t) const { return  ( (fCurrentRow == t.fCurrentRow) && (fThisTable == t.fThisTable) ); }
         Bool_t operator!=(const iterator &t) const { return !operator==(t); }

         const TTable &Table()   const { return *fThisTable;}
         const Long_t &RowSize() const { return fRowSize;}
#ifndef __CINT__
         const std::vector<Long_t>::iterator &Row() const { return fCurrentRow;}
#endif
   };

#ifndef __CINT__
   //  pointer iterator
   // This create an iterator to iterate over all table column of the
   // type provided.
   // For example" piterator(table,kPtr) is to iterate over
   // all cells of (TTableMap *) type

   class piterator {
      private:
         std::vector<ULong_t>  fPtrs;
         UInt_t                fCurrentRowIndex;
         UInt_t                fCurrentColIndex;
         UInt_t                fRowSize;
         const Char_t         *fCurrentRowPtr;
         void                **fCurrentColPtr;

      protected:
         void **column() {return  fCurrentColPtr = (void **)(fCurrentRowPtr + fPtrs[fCurrentColIndex]);}

      public:
         piterator(const TTable *t=0,EColumnType type=kPtr);
         piterator(const piterator& iter);
         void operator=(const piterator& iter);

         void operator++();
         void operator++(int);
         void operator--();
         void operator--(int);

//        operator const char *() const;
         void **operator *();

         Bool_t operator==(const piterator &t) const;
         Bool_t operator!=(const piterator &t) const;

         UInt_t Row()    const;
         UInt_t Column() const;

         void  MakeEnd(UInt_t lastRowIndex);
   }; // class iterator over pointers

   piterator pbegin(){ return piterator(this); }
   piterator pend(){ piterator pLast(this); pLast.MakeEnd(GetNRows()); return pLast; }
#endif
   static const char *TableDictionary() { return 0; };
   ClassDef(TTable,4)  // vector of the C structures
};

//________________________________________________________________________
inline void  TTable::AddAt(TDataSet *dataset,Int_t idx)
{ TDataSet::AddAt(dataset,idx); }

//________________________________________________________________________
inline Bool_t TTable::BoundsOk(const char *where, Int_t at) const
{
   return (at < 0 || at >= fN)
                  ? OutOfBoundsError(where, at)
                  : kTRUE;
}

//________________________________________________________________________
inline  void  *TTable::GetArray() const { return (void *)fTable;}

//________________________________________________________________________
inline  void   TTable::Print(Option_t *) const { Print((Char_t *)0,Int_t(0)); }

//________________________________________________________________________
inline  void   TTable::SetUsedRows(Int_t n) { fMaxIndex = n;}
//________________________________________________________________________
inline  void   TTable::SetNRows(Int_t n) {SetUsedRows(n);}
//   ULong_t   &operator(){ return GetTable();}

//________________________________________________________________________
inline void *TTable::operator[](Int_t i)
{
   if (!BoundsOk("TTable::operator[]", i))
      i = 0;
    return (void *)(fTable+i*fSize);
}

//________________________________________________________________________
inline const void *TTable::operator[](Int_t i) const
{
   if (!BoundsOk("TTable::operator[]", i))
      i = 0;
    return (const void *)(fTable+i*fSize);
}

//________________________________________________________________________
inline void TTable::Draw(Option_t *opt)
{ Draw(opt, "", "", 1000000000, 0); }

#ifndef __CINT__
    //________________________________________________________________________________________________________________
    inline TTable::piterator::piterator(const piterator& iter) :
           fPtrs (iter.fPtrs),
           fCurrentRowIndex(iter.fCurrentRowIndex),
           fCurrentColIndex(iter.fCurrentColIndex),
           fRowSize(iter.fRowSize),
           fCurrentRowPtr(iter.fCurrentRowPtr),
           fCurrentColPtr(iter.fCurrentColPtr)
    {}
    //________________________________________________________________________________________________________________
    inline void TTable::piterator::operator=(const piterator& iter){
        fPtrs            = iter.fPtrs;
        fCurrentRowIndex = iter.fCurrentRowIndex;
        fCurrentColIndex = iter.fCurrentColIndex;
        fRowSize         = iter.fRowSize;
        fCurrentRowPtr   = iter.fCurrentRowPtr;
        fCurrentColPtr   = iter.fCurrentColPtr;
    }
    //________________________________________________________________________________________________________________
    inline void TTable::piterator::operator++()
    {
       ++fCurrentColIndex;
         if (fCurrentColIndex >= fPtrs.size()) {
           fCurrentColIndex = 0;
         ++fCurrentRowIndex;
           fCurrentRowPtr += fRowSize;
         }
         column();
    }
    //________________________________________________________________________________________________________________
    inline void TTable::piterator::operator++(int) {  operator++(); }
    //________________________________________________________________________________________________________________
    inline void TTable::piterator::operator--()
    {
       if (fCurrentColIndex > 0) {
          fCurrentColIndex--;
          fCurrentColIndex = fPtrs.size()-1;
        --fCurrentRowIndex;
          fCurrentRowPtr -= fRowSize;
       } else {
          fCurrentColIndex--;
       }
       column();
    }
    //________________________________________________________________________________________________________________
    inline void TTable::piterator::operator--(int) {  operator--();  }
    //________________________________________________________________________________________________________________
    // inline TTable::piterator::operator const char *() const { return fCurrentColPtr; }
    //________________________________________________________________________________________________________________
    inline void **TTable::piterator::operator *()            { return fCurrentColPtr; }
    //________________________________________________________________________________________________________________
    inline Bool_t TTable::piterator::operator==(const piterator &t) const {
        return  (
                 (fCurrentRowIndex== t.fCurrentRowIndex)
              && (fCurrentColIndex == t.fCurrentColIndex)
//              && (fCurrentRowPtr == t.fCurrentRowPtr )
//              && (fCurrentColPtr == t.fCurrentColPtr )
                );
    }
    //________________________________________________________________________________________________________________
    inline Bool_t TTable::piterator::operator!=(const piterator &t) const { return !operator==(t); }
    //________________________________________________________________________________________________________________
    inline void  TTable::piterator::MakeEnd(UInt_t lastRowIndex){fCurrentColIndex = 0; fCurrentRowIndex = lastRowIndex;}
    //________________________________________________________________________________________________________________
    inline UInt_t TTable::piterator::Row()    const { return fCurrentRowIndex;}
    //________________________________________________________________________________________________________________
    inline UInt_t TTable::piterator::Column() const { return fCurrentColIndex;}
#endif
#include "TTableDescriptor.h"

#endif
 TTable.h:1
 TTable.h:2
 TTable.h:3
 TTable.h:4
 TTable.h:5
 TTable.h:6
 TTable.h:7
 TTable.h:8
 TTable.h:9
 TTable.h:10
 TTable.h:11
 TTable.h:12
 TTable.h:13
 TTable.h:14
 TTable.h:15
 TTable.h:16
 TTable.h:17
 TTable.h:18
 TTable.h:19
 TTable.h:20
 TTable.h:21
 TTable.h:22
 TTable.h:23
 TTable.h:24
 TTable.h:25
 TTable.h:26
 TTable.h:27
 TTable.h:28
 TTable.h:29
 TTable.h:30
 TTable.h:31
 TTable.h:32
 TTable.h:33
 TTable.h:34
 TTable.h:35
 TTable.h:36
 TTable.h:37
 TTable.h:38
 TTable.h:39
 TTable.h:40
 TTable.h:41
 TTable.h:42
 TTable.h:43
 TTable.h:44
 TTable.h:45
 TTable.h:46
 TTable.h:47
 TTable.h:48
 TTable.h:49
 TTable.h:50
 TTable.h:51
 TTable.h:52
 TTable.h:53
 TTable.h:54
 TTable.h:55
 TTable.h:56
 TTable.h:57
 TTable.h:58
 TTable.h:59
 TTable.h:60
 TTable.h:61
 TTable.h:62
 TTable.h:63
 TTable.h:64
 TTable.h:65
 TTable.h:66
 TTable.h:67
 TTable.h:68
 TTable.h:69
 TTable.h:70
 TTable.h:71
 TTable.h:72
 TTable.h:73
 TTable.h:74
 TTable.h:75
 TTable.h:76
 TTable.h:77
 TTable.h:78
 TTable.h:79
 TTable.h:80
 TTable.h:81
 TTable.h:82
 TTable.h:83
 TTable.h:84
 TTable.h:85
 TTable.h:86
 TTable.h:87
 TTable.h:88
 TTable.h:89
 TTable.h:90
 TTable.h:91
 TTable.h:92
 TTable.h:93
 TTable.h:94
 TTable.h:95
 TTable.h:96
 TTable.h:97
 TTable.h:98
 TTable.h:99
 TTable.h:100
 TTable.h:101
 TTable.h:102
 TTable.h:103
 TTable.h:104
 TTable.h:105
 TTable.h:106
 TTable.h:107
 TTable.h:108
 TTable.h:109
 TTable.h:110
 TTable.h:111
 TTable.h:112
 TTable.h:113
 TTable.h:114
 TTable.h:115
 TTable.h:116
 TTable.h:117
 TTable.h:118
 TTable.h:119
 TTable.h:120
 TTable.h:121
 TTable.h:122
 TTable.h:123
 TTable.h:124
 TTable.h:125
 TTable.h:126
 TTable.h:127
 TTable.h:128
 TTable.h:129
 TTable.h:130
 TTable.h:131
 TTable.h:132
 TTable.h:133
 TTable.h:134
 TTable.h:135
 TTable.h:136
 TTable.h:137
 TTable.h:138
 TTable.h:139
 TTable.h:140
 TTable.h:141
 TTable.h:142
 TTable.h:143
 TTable.h:144
 TTable.h:145
 TTable.h:146
 TTable.h:147
 TTable.h:148
 TTable.h:149
 TTable.h:150
 TTable.h:151
 TTable.h:152
 TTable.h:153
 TTable.h:154
 TTable.h:155
 TTable.h:156
 TTable.h:157
 TTable.h:158
 TTable.h:159
 TTable.h:160
 TTable.h:161
 TTable.h:162
 TTable.h:163
 TTable.h:164
 TTable.h:165
 TTable.h:166
 TTable.h:167
 TTable.h:168
 TTable.h:169
 TTable.h:170
 TTable.h:171
 TTable.h:172
 TTable.h:173
 TTable.h:174
 TTable.h:175
 TTable.h:176
 TTable.h:177
 TTable.h:178
 TTable.h:179
 TTable.h:180
 TTable.h:181
 TTable.h:182
 TTable.h:183
 TTable.h:184
 TTable.h:185
 TTable.h:186
 TTable.h:187
 TTable.h:188
 TTable.h:189
 TTable.h:190
 TTable.h:191
 TTable.h:192
 TTable.h:193
 TTable.h:194
 TTable.h:195
 TTable.h:196
 TTable.h:197
 TTable.h:198
 TTable.h:199
 TTable.h:200
 TTable.h:201
 TTable.h:202
 TTable.h:203
 TTable.h:204
 TTable.h:205
 TTable.h:206
 TTable.h:207
 TTable.h:208
 TTable.h:209
 TTable.h:210
 TTable.h:211
 TTable.h:212
 TTable.h:213
 TTable.h:214
 TTable.h:215
 TTable.h:216
 TTable.h:217
 TTable.h:218
 TTable.h:219
 TTable.h:220
 TTable.h:221
 TTable.h:222
 TTable.h:223
 TTable.h:224
 TTable.h:225
 TTable.h:226
 TTable.h:227
 TTable.h:228
 TTable.h:229
 TTable.h:230
 TTable.h:231
 TTable.h:232
 TTable.h:233
 TTable.h:234
 TTable.h:235
 TTable.h:236
 TTable.h:237
 TTable.h:238
 TTable.h:239
 TTable.h:240
 TTable.h:241
 TTable.h:242
 TTable.h:243
 TTable.h:244
 TTable.h:245
 TTable.h:246
 TTable.h:247
 TTable.h:248
 TTable.h:249
 TTable.h:250
 TTable.h:251
 TTable.h:252
 TTable.h:253
 TTable.h:254
 TTable.h:255
 TTable.h:256
 TTable.h:257
 TTable.h:258
 TTable.h:259
 TTable.h:260
 TTable.h:261
 TTable.h:262
 TTable.h:263
 TTable.h:264
 TTable.h:265
 TTable.h:266
 TTable.h:267
 TTable.h:268
 TTable.h:269
 TTable.h:270
 TTable.h:271
 TTable.h:272
 TTable.h:273
 TTable.h:274
 TTable.h:275
 TTable.h:276
 TTable.h:277
 TTable.h:278
 TTable.h:279
 TTable.h:280
 TTable.h:281
 TTable.h:282
 TTable.h:283
 TTable.h:284
 TTable.h:285
 TTable.h:286
 TTable.h:287
 TTable.h:288
 TTable.h:289
 TTable.h:290
 TTable.h:291
 TTable.h:292
 TTable.h:293
 TTable.h:294
 TTable.h:295
 TTable.h:296
 TTable.h:297
 TTable.h:298
 TTable.h:299
 TTable.h:300
 TTable.h:301
 TTable.h:302
 TTable.h:303
 TTable.h:304
 TTable.h:305
 TTable.h:306
 TTable.h:307
 TTable.h:308
 TTable.h:309
 TTable.h:310
 TTable.h:311
 TTable.h:312
 TTable.h:313
 TTable.h:314
 TTable.h:315
 TTable.h:316
 TTable.h:317
 TTable.h:318
 TTable.h:319
 TTable.h:320
 TTable.h:321
 TTable.h:322
 TTable.h:323
 TTable.h:324
 TTable.h:325
 TTable.h:326
 TTable.h:327
 TTable.h:328
 TTable.h:329
 TTable.h:330
 TTable.h:331
 TTable.h:332
 TTable.h:333
 TTable.h:334
 TTable.h:335
 TTable.h:336
 TTable.h:337
 TTable.h:338
 TTable.h:339
 TTable.h:340
 TTable.h:341
 TTable.h:342
 TTable.h:343
 TTable.h:344
 TTable.h:345
 TTable.h:346
 TTable.h:347
 TTable.h:348
 TTable.h:349
 TTable.h:350
 TTable.h:351
 TTable.h:352
 TTable.h:353
 TTable.h:354
 TTable.h:355
 TTable.h:356
 TTable.h:357
 TTable.h:358
 TTable.h:359
 TTable.h:360
 TTable.h:361
 TTable.h:362
 TTable.h:363
 TTable.h:364
 TTable.h:365
 TTable.h:366
 TTable.h:367
 TTable.h:368
 TTable.h:369
 TTable.h:370
 TTable.h:371
 TTable.h:372
 TTable.h:373
 TTable.h:374
 TTable.h:375
 TTable.h:376
 TTable.h:377
 TTable.h:378
 TTable.h:379
 TTable.h:380
 TTable.h:381
 TTable.h:382
 TTable.h:383
 TTable.h:384
 TTable.h:385
 TTable.h:386