// @(#)root/star:$Name:  $:$Id: TTable.h,v 1.5 2003/01/31 08:24:18 brun Exp $
// 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

//#if ROOT_VERSION_CODE >= ROOT_VERSION(3,03,5)
# ifndef ROOT_Riosfwd
#  include "Riosfwd.h"
# endif
#if defined(R__ANSISTREAM)
    using namespace std;
#endif 

// #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 Text_t *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
                    , 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 Text_t *name=0, Int_t size=0);
   TTable(const Text_t *name, Int_t n,Int_t size);
   TTable(const Text_t *name, Int_t n, Char_t *array,Int_t size);
   TTable(const Text_t *name, const Text_t *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     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 Text_t *varexp, const Text_t *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 Text_t *formula ,const Text_t *varexp, const Text_t *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 Text_t *hname, const Text_t *varexp, const Text_t *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(ofstream &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 {
      private:
	       Long_t        fRowSize;
         const TTable *fThisTable;
		     vector<Long_t>::iterator fCurrentRow;
      public:
	     iterator(): fRowSize(0), fThisTable(0) {;}
        iterator(const TTable &table,vector<Long_t>::iterator &rowPtr) : fRowSize(table.GetRowSize()), fThisTable(&table), fCurrentRow(rowPtr) {;}
        iterator(const TTable &table,vector<Long_t>::const_iterator &rowPtr) : fRowSize(table.GetRowSize()), fThisTable(&table), fCurrentRow(*(vector<Long_t>::iterator *)(void *)&rowPtr) {;}
        iterator(const iterator& iter) : fRowSize (iter.fRowSize), fThisTable(iter.fThisTable),fCurrentRow(iter.fCurrentRow){}
        void operator=(const iterator& iter)   { fRowSize = iter.fRowSize; fThisTable = iter.fThisTable; fCurrentRow=iter.fCurrentRow; }
        void operator++()    { ++fCurrentRow;   }
        void operator++(int) {   fCurrentRow++; }
        void operator--()    { --fCurrentRow;   }
        void operator--(int) {   fCurrentRow--; }
        iterator operator+(Int_t idx)   { vector<Long_t>::iterator addition   = fCurrentRow+idx; return  iterator(*fThisTable,addition); }
        iterator operator-(Int_t idx)   { 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 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:
		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 const char *TTable::GetTypeName(TTable::EColumnType type)
{  return  fgTypeName[type]; }

//________________________________________________________________________
inline TTable::EColumnType TTable::GetTypeId(const char *typeName)
{
  //
  // return the Id of the C basic type by given name
  // return kNAN if the name provided fits no knwn basic name.
  //
  Int_t allTypes = sizeof(fgTypeName)/sizeof(const char *);
  for (int i = 0; i < allTypes; i++)
  if (!strcmp(fgTypeName[i],typeName)) return EColumnType(i);
  return kNAN;
}

//________________________________________________________________________
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),
           fCurrentRowPtr(iter.fCurrentRowPtr),
           fCurrentColPtr(iter.fCurrentColPtr)
    {}   
    //________________________________________________________________________________________________________________
    inline void TTable::piterator::operator=(const piterator& iter){
        fPtrs            = iter.fPtrs;
        fCurrentRowIndex = iter.fCurrentRowIndex;
        fCurrentColIndex = iter.fCurrentColIndex;
        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


ROOT page - Class index - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.