[root] / trunk / tree / tree / inc / TSelectorCint.h Repository:
ViewVC logotype

Log of /trunk/tree/tree/inc/TSelectorCint.h

Parent Directory Parent Directory


Links to HEAD: (view) (download) (as text) (annotate)
Sticky Revision:

Revision 38871 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Fri Apr 15 11:35:38 2011 UTC (3 years, 9 months ago) by pcanal
File length: 3625 byte(s)
Diff to previous 38869
White spaces

Revision 38869 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Fri Apr 15 11:29:04 2011 UTC (3 years, 9 months ago) by pcanal
File length: 3583 byte(s)
Diff to previous 34509
Patch to correctly honour selector abort status settings in TTreePlayer::Process. Currently only
  the TSelector::kAbortProcess was handled by stopping processing. In particular
  TSelector::kAbortFile was ignored; this recently created some problems in ALICE
  with corrupted files, with repeated attempts to read events eventually leading to
  bad_alloc exceptions.

Revision 34509 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Tue Jul 20 12:18:17 2010 UTC (4 years, 6 months ago) by rdm
File length: 3398 byte(s)
Diff to previous 24077
From Axel:
allow access to interpreted TClass and selector.

Revision 24077 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Sat May 31 19:39:09 2008 UTC (6 years, 7 months ago) by brun
File length: 3267 byte(s)
Diff to previous 22902
Extend the TInterpreter class to support the CINT API used so far by ROOT.
The concrete implementation of the class is in TCint.
The new functions are essentially interfaces to the existing CINT C++ classes
like G__ClassInfo, G__CallFunc, G__DataMemberInfo, G__MethodInfo, G__TypeInfo
and G__TypedefInfo. Most of these functions will call the Reflex interface
once the CINT/Reflex interface will be available later this year.
All direct calls to CINT are replaced by calls like gCint->ClassInfo_xxx where gCint
points to the TCint implementation.
The existing calls to TCint via gInterpreter are kept because on Windows
gInterpreter does not call directly TCint, but instead call TWin32InterpreterProxy
that in turns call TCint.
On Linux and Mac, gInterpreter and gCint are equivalent.

Once the transformation using gCint will be completed, it will be possible
to specify at startup time which version of CINT (CINT or CINT7) by loading
dynamically TCint or TCint7.--This line, and those below, will be ignored--

M    core/meta/src/TStreamerElement.cxx
M    core/meta/src/TCint.cxx
M    core/meta/src/TGlobal.cxx
M    core/meta/src/TBaseClass.cxx
M    core/meta/src/TDataMember.cxx
M    core/meta/src/TInterpreter.cxx
M    core/meta/src/TClass.cxx
M    core/meta/src/TMethodArg.cxx
M    core/meta/src/TDataType.cxx
M    core/meta/src/TMethodCall.cxx
M    core/meta/src/TIsAProxy.cxx
M    core/meta/src/TMethod.cxx
M    core/meta/src/TFunction.cxx
M    core/meta/inc/TClass.h
M    core/meta/inc/TDictionary.h
M    core/meta/inc/TMethodArg.h
M    core/meta/inc/TDataType.h
M    core/meta/inc/TMethodCall.h
M    core/meta/inc/TMethod.h
M    core/meta/inc/TFunction.h
M    core/meta/inc/TCint.h
M    core/meta/inc/TGlobal.h
M    core/meta/inc/TBaseClass.h
M    core/meta/inc/TDataMember.h
M    core/meta/inc/TInterpreter.h
M    core/thread/src/TThread.cxx
M    core/base/src/TVirtualFitter.cxx
M    core/base/src/TStorage.cxx
M    core/base/src/TQConnection.cxx
M    core/base/src/TROOT.cxx
M    core/base/src/TSystem.cxx
M    core/base/src/TQObject.cxx
M    core/rint/src/TRint.cxx
M    core/rint/src/TTabCom.cxx
M    math/foam/src/TFoam.cxx
M    math/minuit2/src/TFitterMinuit.cxx
M    math/mathcore/src/FunctorCint.cxx
M    math/minuit/src/TMinuit.cxx
M    tree/tree/src/TTree.cxx
M    tree/tree/src/TSelectorCint.cxx
M    tree/tree/src/TSelector.cxx
M    tree/tree/inc/TSelectorCint.h
M    roofit/roofitcore/src/RooGenCategory.cxx
M    roofit/roofitcore/src/RooWorkspace.cxx
M    hist/hist/src/TF1.cxx
M    gui/guibuilder/src/TGuiBldDragManager.cxx
M    net/alien/inc/TAlienSystem.h

Revision 22902 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Mon Mar 31 09:48:42 2008 UTC (6 years, 9 months ago) by rdm
File length: 3414 byte(s)
Diff to previous 20882
move tree, treeplayer and treeviewer under tree meta directory.

Revision 20882 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Mon Nov 19 11:31:26 2007 UTC (7 years, 2 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3414 byte(s)
Diff to previous 19826
Set property svn:eol-style LF on all source and Makefiles. This should avoid
problems with Win32 line endings ending up in the repository. All MS tools
support LF eols fine.

Revision 19826 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Wed Sep 19 19:56:11 2007 UTC (7 years, 4 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3414 byte(s)
Diff to previous 19825
imported svn:keywords Id property

Revision 19825 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Wed Sep 19 19:49:10 2007 UTC (7 years, 4 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3470 byte(s)
Diff to previous 19637
remove :$ from tag line

Revision 19637 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Fri Aug 17 19:08:28 2007 UTC (7 years, 5 months ago) by pcanal
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3480 byte(s)
Diff to previous 18814
allows the header files to be #included without
requiring extra (dependent) #includes.

Revision 18814 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Thu May 17 22:19:34 2007 UTC (7 years, 8 months ago) by pcanal
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3357 byte(s)
Diff to previous 16926
Add the ability for the TSelectorCint do not 'own' the underlying interpreted selector

Revision 16926 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Fri Nov 24 14:24:54 2006 UTC (8 years, 2 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3227 byte(s)
Diff to previous 15935
patch handling namespace CINT of CINT 5-16-16.

Revision 15935 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Sun Aug 6 07:15:01 2006 UTC (8 years, 5 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3202 byte(s)
Diff to previous 15690
Handle several issues related to the TTree::Process() and TTree::Draw()
return values:
- TSelector: fStatus increased from Int_t to Long64_t. It is used to
  return the number of selected events by TTree::Draw() which returns
  a Long64_t.
- TVirtualProof, TProof, TDSet, TProofPlayer: Process() and Draw() were
  returning an Int_t, now a Long64_t to be consistent with TTree/TChain.
  Actually returning of TSelector::GetStatus() from the workers to be
  done tomorrow.
  Also added proper comments describing the return values for Draw()
  (number of selected events), and Process() (value returned by
  TSelector::GetStatus()).
- TTree, TChain, TSelectorDraw: added proper comments describing the
  return values of Draw() and Process().

Revision 15690 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Tue Jul 4 23:35:37 2006 UTC (8 years, 6 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3202 byte(s)
Diff to previous 11154
Some new features in TSelector and derivatives:
- new method Abort() which allows Process() to be aborted by the user
  from within the selector. After Abort(), either the Process() is aborted
  or the current file is aborted and the next file in a chain will be
  processed. Abort() can also be called from Begin(), SlaveBegin(),
  Init() and Notify() to interrupt processing. In all cases SlaveTerminate()
  and Terminate() are still called.
- new method GetEntry() which is a wrapper around:
    fChain->GetTree()->GetEntry()
- GetStatus() now also implemented in TSelectorCint so the selector
  fStatus is correctly reported back by TTree::Process() also for
  interpreted selectors (also documented in the generated selector).
- documented in the generated selector code that the boolean return
  values of Notify() and Process() are not used.
- fixed a bug in TProofPlayer() that caused Init() and Notify() to be
  called for every packet and not once per file.

Revision 11154 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Mon Feb 21 09:41:39 2005 UTC (9 years, 11 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3046 byte(s)
Diff to previous 9615
package name in cvs tag was not correct.

Revision 9615 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Thu Jul 29 10:54:55 2004 UTC (10 years, 5 months ago) by brun
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3051 byte(s)
Diff to previous 7338

*****************WARNING*****************
With this mega patch, we introduce support for TTree/TChain  with more than
2 billion entries. Several class data members have been changed from
Int_t (or Stat_t) to Long64_t.
==>Trees written with this new version cannot be read with older versions
******************************************

TBranch:
========
 - replace the members with type Int_t or Stat_t by Long64_t
    Long64_t    fEntryNumber;     //  Current entry number (last one filled in this branch)
    Long64_t    fReadEntry;       //! Current entry number when reading
    Long64_t    fEntries;         //  Number of entries
    Long64_t    fTotBytes;        //  Total number of bytes in all leaves before compression
    Long64_t    fZipBytes;        //  Total number of bytes in all leaves after compression
    Long64_t   *fBasketEntry;     //[fMaxBaskets] Table of first entry in eack basket

 - corresponding changes in the member functions
    virtual Int_t     GetEntry(Long64_t entry=0, Int_t getall = 0);
    virtual Int_t     GetEntryExport(Long64_t entry, Int_t getall, TClonesArray *list, Int_t n);
            Int_t     GetEvent(Long64_t entry=0) {return GetEntry(entry);}
            Long64_t *GetBasketEntry() const {return fBasketEntry;}
            Long64_t  GetReadEntry()   const {return fReadEntry;}
            Long64_t  GetTotalSize()   const;
            Long64_t  GetTotBytes()    const {return fTotBytes;}
            Long64_t  GetZipBytes()    const {return fZipBytes;}
            Long64_t  GetEntryNumber() const {return fEntryNumber;}
            Long64_t  GetEntries()     const {return fEntries;}

TBranch::Streamer has been modified to read old files and automatically translate
the old types to the new types.
The new version of Streamer uses the TClass::ReadBuffer/WriteBuffer.

TBranch::Print has been modified to take into account the new data types.

ClassDef version increased to 10.

TBranchClones:
==============
    virtual Int_t    GetEntry(Long64_t entry=0, Int_t getall = 0);

TBranchElement:
===============
            Int_t    GetEntry(Long64_t entry=0, Int_t getall = 0);

TBranchObject:
==============
    virtual Int_t    GetEntry(Long64_t entry=0, Int_t getall = 0);

TChain:
=======
    Long64_t    *fTreeOffset;       //[fTreeOffsetLen]Array of variables

    virtual Int_t     Add(const char *name, Long64_t nentries=kBigNumber);
    virtual Int_t     AddFile(const char *name, Long64_t nentries=kBigNumber);
    virtual Long64_t  Draw(const char *varexp, const TCut &selection, Option_t *option=""
                       ,Long64_t nentries=kBigNumber, Long64_t firstentry=0);
    virtual Long64_t  Draw(const char *varexp, const char *selection, Option_t *option=""
                     ,Long64_t nentries=kBigNumber, Long64_t firstentry=0); // *MENU*
    virtual Long64_t  GetChainEntryNumber(Long64_t entry) const;
    virtual Long64_t  GetEntries() const;
    virtual Int_t     GetEntry(Long64_t entry=0, Int_t getall=0);
            Long64_t  LoadTree(Long64_t entry);
    virtual void      Loop(Option_t *option="",Long64_t nentries=kBigNumber, Long64_t firstentry=0); // *MENU*
    virtual Long64_t  Merge(const char *name);
    virtual Long64_t  Merge(TCollection *list);
    virtual Long64_t  Merge(TFile *file, Int_t basketsize, Option_t *option="");
    virtual Long64_t  Process(const char *filename,Option_t *option="", Long64_t nentries=kBigNumber, Long64_t firstentry=0); // *MENU*
    virtual Long64_t  Process(TSelector *selector,Option_t *option="",  Long64_t nentries=kBigNumber, Long64_t firstentry=0);

ClassDef version changed from 4 to 5

TSelector
=========
   virtual Bool_t      ProcessCut(Long64_t /*entry*/) { return kTRUE; }
   virtual void        ProcessFill(Long64_t /*entry*/) { }
   virtual Bool_t      Process(Long64_t /*entry*/) { return kFALSE; }

TSelectorCint
=============
   virtual Bool_t      ProcessCut(Long64_t entry);
   virtual void        ProcessFill(Long64_t entry);
   virtual Bool_t      Process(Long64_t entry);

TSelectorDraw
=============
    Long64_t       fDraw;           //! Last entry loop number when object was drawn
    Long64_t       fSelectedRows;   //  Number of selected entries
    Long64_t       fOldEstimate;    //  value of Tree fEstimate when selector is called
    Double_t      *fV1;             //![fSelectedRows]Local buffer for variable 1
    Double_t      *fV2;             //![fSelectedRows]Local buffer for variable 2
    Double_t      *fV3;             //![fSelectedRows]Local buffer for variable 3
    Double_t      *fV4;             //![fSelectedRows]Local buffer for variable 4
    Double_t      *fW;              //![fSelectedRows]Local buffer for weights

    virtual Long64_t  GetSelectedRows() const {return fSelectedRows;}
    virtual Bool_t    Process(Long64_t /*entry*/) { return kFALSE; }
    virtual void      ProcessFill(Long64_t entry);
    virtual void      ProcessFillMultiple(Long64_t entry);
    virtual void      ProcessFillObject(Long64_t entry);
    virtual void      SetEstimate(Long64_t n);

TTree
=====
Modified data types
    Long64_t       fEntries;           //  Number of entries
    Long64_t       fTotBytes;          //  Total number of bytes in all branches before compression
    Long64_t       fZipBytes;          //  Total number of bytes in all branches after compression
    Long64_t       fSavedBytes;        //  Number of autosaved bytes
    Long64_t       fMaxEntryLoop;      //  Maximum number of entries to process
    Long64_t       fMaxVirtualSize;    //  Maximum total size of buffers kept in memory
    Long64_t       fAutoSave;          //  Autosave tree when fAutoSave bytes produced
    Long64_t       fEstimate;          //  Number of entries to estimate histogram limits
    Long64_t       fChainOffset;       //! Offset of 1st entry of this Tree in a TChain
    Long64_t       fReadEntry;         //! Number of the entry being processed
    Long64_t       fTotalBuffers;      //! Total number of bytes in branch buffers
    Long64_t       fDebugMin;          //! First entry number to debug
    Long64_t       fDebugMax;          //! Last entry number to debug

New function signatures
    virtual Long64_t     AutoSave(Option_t *option="");
    virtual TTree       *CloneTree(Long64_t nentries=-1, Option_t *option="");
    virtual Long64_t     CopyEntries(TTree *tree, Long64_t nentries=-1);
    virtual TTree       *CopyTree(const char *selection, Option_t *option=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0);
    virtual Long64_t     Draw(const char *varexp, const TCut &selection, Option_t *option=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0);
    virtual Long64_t     Draw(const char *varexp, const char *selection, Option_t *option=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0); // *MENU*
    virtual Long64_t     Fit(const char *funcname ,const char *varexp, const char *selection="",Option_t *option="" ,Option_t *goption=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0); // *MENU*
    virtual Long64_t     GetChainEntryNumber(Long64_t entry) const {return entry;}
    virtual Long64_t     GetChainOffset() const { return fChainOffset; }
            Long64_t     GetDebugMax()  const {return fDebugMax;}
            Long64_t     GetDebugMin()  const {return fDebugMin;}
    virtual Long64_t     GetEntries() const   {return fEntries;}
    virtual Long64_t     GetEntriesFast() const   {return fEntries;}
    virtual Long64_t     GetEntriesFriend() const;
    virtual Long64_t     GetEstimate() const { return fEstimate; }
    virtual Int_t        GetEntry(Long64_t entry=0, Int_t getall=0);
            Int_t        GetEvent(Long64_t entry=0, Int_t getall=0) {return GetEntry(entry,getall);}
    virtual Long64_t     GetEntryNumberWithBestIndex(Int_t major, Int_t minor=0) const;
    virtual Long64_t     GetEntryNumberWithIndex(Int_t major, Int_t minor=0) const;
    virtual Long64_t     GetEntryNumber(Long64_t entry) const;
    virtual Long64_t     GetMaxEntryLoop() const {return fMaxEntryLoop;}
    static  Long64_t     GetMaxTreeSize();
    virtual Long64_t     GetMaxVirtualSize() const {return fMaxVirtualSize;}
    virtual Long64_t     GetReadEntry()  const {return fReadEntry;}
    virtual Long64_t     GetReadEvent()  const {return fReadEntry;}
    virtual Long64_t     GetSelectedRows() {return GetPlayer()->GetSelectedRows();}
    virtual Long64_t     GetTotBytes() const {return fTotBytes;}
    virtual Long64_t     GetZipBytes() const {return fZipBytes;}
    virtual Long64_t     LoadTree(Long64_t entry);
    virtual Long64_t     LoadTreeFriend(Long64_t entry, TTree *T);
    virtual Long64_t     Merge(TCollection *list);
    TPrincipal          *Principal(const char *varexp="", const char *selection="", Option_t *option="np"
                                   ,Long64_t nentries=1000000000, Long64_t firstentry=0);
    virtual Long64_t     Process(const char *filename,Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0); // *MENU*
    virtual Long64_t     Process(TSelector *selector, Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0);
    virtual Long64_t     Project(const char *hname, const char *varexp, const char *selection="", Option_t *option=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0);
    virtual TSQLResult  *Query(const char *varexp="", const char *selection="", Option_t *option=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0);
    virtual Long64_t     Scan(const char *varexp="", const char *selection="", Option_t *option=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0); // *MENU*
    virtual void         SetDebug(Int_t level=1, Long64_t min=0, Long64_t max=9999999); // *MENU*
    virtual void         SetEntries(Long64_t n);
    virtual void         SetEstimate(Long64_t nentries=10000);
    virtual void         SetMaxEntryLoop(Long64_t maxev=1000000000) {fMaxEntryLoop = maxev;} // *MENU*
    static  void         SetMaxTreeSize(Long64_t maxsize=1900000000);
    virtual void         SetMaxVirtualSize(Long64_t size=0) {fMaxVirtualSize = size;} // *MENU*
    virtual void         Show(Long64_t entry=-1, Int_t lenmax=20);
    virtual Long64_t     UnbinnedFit(const char *funcname ,const char *varexp, const char *selection="",Option_t *option=""
                          ,Long64_t nentries=1000000000, Long64_t firstentry=0);

TTree::Streamer has been modified to real old files.
TTree::Print has been modified to take into account the new data types.

ClassDef version number incremented to 13.

TVirtualTreePlayer
==================
    virtual TTree         *CopyTree(const char *selection, Option_t *option=""
                            ,Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
    virtual Long64_t       DrawScript(const char* wrapperPrefix,
                                      const char *macrofilename, const char *cutfilename,
                                      Option_t *option, Long64_t nentries, Long64_t firstentry) = 0;
    virtual Long64_t       DrawSelect(const char *varexp, const char *selection, Option_t *option
                            ,Long64_t nentries, Long64_t firstentry) = 0;
    virtual Long64_t       Fit(const char *formula ,const char *varexp, const char *selection,Option_t *option ,Option_t *goption
                            ,Long64_t nentries, Long64_t firstentry) = 0;
    virtual Long64_t       GetSelectedRows() const = 0;
    virtual TPrincipal    *Principal(const char *varexp="", const char *selection="", Option_t *option="np"
                           ,Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
    virtual Long64_t       Process(const char *filename,Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
    virtual Long64_t       Process(TSelector *selector,Option_t *option="",  Long64_t nentries=1000000000, Long64_t firstentry=0) = 0;
    virtual Long64_t       Scan(const char *varexp, const char *selection, Option_t *option
                            ,Long64_t nentries, Long64_t firstentry) = 0;
    virtual TSQLResult    *Query(const char *varexp, const char *selection, Option_t *option
                            ,Long64_t nentries, Long64_t firstentry) = 0;
    virtual void           SetEstimate(Long64_t n) = 0;
    virtual Long64_t       UnbinnedFit(const char *formula ,const char *varexp, const char *selection,Option_t *option
                            ,Long64_t nentries, Long64_t firstentry) = 0;

TTreeFormula
============
   TLeaf*      GetLeafWithDatamember(const char* topchoice, const char* nextchice, Long64_t readentry) const;
   Bool_t      BranchHasMethod(TLeaf* leaf, TBranch* branch,
                               const char* method,const char* params,
                               Long64_t readentry) const;

TTreePlayer
===========
    Long64_t       fSelectedRows;    //  Number of selected entries

    virtual TTree    *CopyTree(const char *selection, Option_t *option
                       ,Long64_t nentries, Long64_t firstentry);
    virtual Long64_t  DrawScript(const char* wrapperPrefix,
                                 const char *macrofilename, const char *cutfilename,
                                 Option_t *option, Long64_t nentries, Long64_t firstentry);
    virtual Long64_t  DrawSelect(const char *varexp, const char *selection, Option_t *option
                                 ,Long64_t nentries, Long64_t firstentry);
    virtual Long64_t  Fit(const char *formula ,const char *varexp, const char *selection,Option_t *option ,
                          Option_t *goption ,Long64_t nentries, Long64_t firstentry);
    virtual Long64_t  GetSelectedRows() const {return fSelectedRows;}
    TPrincipal       *Principal(const char *varexp, const char *selection, Option_t *option
                       ,Long64_t nentries, Long64_t firstentry);
    virtual Long64_t  Process(const char *filename,Option_t *option, Long64_t nentries, Long64_t firstentry);
    virtual Long64_t  Process(TSelector *selector,Option_t *option,  Long64_t nentries, Long64_t firstentry);
    virtual Long64_t  Scan(const char *varexp, const char *selection, Option_t *option
                       ,Long64_t nentries, Long64_t firstentry);
    virtual TSQLResult *Query(const char *varexp, const char *selection, Option_t *option
                         ,Long64_t nentries, Long64_t firstentry);
    virtual void      SetEstimate(Long64_t n);
    virtual Long64_t  UnbinnedFit(const char *formula ,const char *varexp, const char *selection,Option_t *option
                       ,Long64_t nentries, Long64_t firstentry);

The generated code by TTreePlayer::MakeCode, MakeClass, MakeProxy
uses Long64_t instead of Int_t

TTreeViewer
===========
    Long64_t      Process(const char* filename, Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0); // *MENU*
    void          SetCurrentRecord(Long64_t entry);

THbookBranch
============
    virtual Int_t    GetEntry(Long64_t entry=0, Int_t getall=0);
    virtual void     SetEntries(Long64_t n) {fEntries=n;}

THbookTree
==========
    virtual Int_t    GetEntry(Long64_t entry=0, Int_t getall=0);
    virtual void     InitBranches(Long64_t entry);
    virtual void     SetEntries(Long64_t n);

TProofDraw
==========
    virtual Bool_t   Process(Long64_t /*entry*/);

TProofPlayer
============
    virtual Long64_t  Process(TDSet *set,
    virtual Long64_t  DrawSelect(TDSet *set, const char *varexp,
    Long64_t          Process(TDSet *set, const char *selector,
    Long64_t          DrawSelect(TDSet *set, const char *varexp,

Revision 7338 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Tue Sep 23 17:20:06 2003 UTC (11 years, 4 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3042 byte(s)
Diff to previous 7333
from Maarten:
make TSelector::Version() const.

Revision 7333 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Tue Sep 23 14:51:16 2003 UTC (11 years, 4 months ago) by brun
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 3035 byte(s)
Diff to previous 6803
From  Maarten Ballintijn
New selector code, modified TTreePlayer and TProofPlayer.
These mods are a first step to get TTree::Draw working with PROOF.

Revision 6803 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Mon Jun 30 10:07:32 2003 UTC (11 years, 6 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2781 byte(s)
Diff to previous 6353
for consistency use Int_t instead of int in Process() arguments. In the
future this should become Long64_t to be inline with the rest of PROOF.

Revision 6353 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Wed Apr 2 06:24:32 2003 UTC (11 years, 9 months ago) by brun
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2774 byte(s)
Diff to previous 4385
From Philippe:
TSelectorCint used (indirectly) G__MethodInfo objects that were
constructed using a G__ClassInfo constructed on the stack.
However the G__MethodInfo objects remember this address and
then tried to use it (and sometimes failed weirdly).

I fixed the problem by making sure that the G__ClassInfo objects
known by the G__MethodInfo objects had the same life time.

Revision 4385 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Fri Apr 19 18:24:02 2002 UTC (12 years, 9 months ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2737 byte(s)
Diff to previous 3699
Major PROOF updates from both Maarten and me. Coming close to a working
system.

Revision 3699 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Fri Jan 18 14:24:10 2002 UTC (13 years ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2529 byte(s)
Diff to previous 3657
relocate some proof file to remove circular dependencies between the
treeplayer and proof shared libraries. Also rename TPlayer to TProofPlayer
et al. Also remove Begin() from TSelector, use Begin(0) instead. This to
be backward compatible with existing TSelector scripts that don't have
Begin() and therefor give warnings about Begin() being hidden in the base
class.

Revision 3657 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Tue Jan 15 00:45:21 2002 UTC (13 years ago) by rdm
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2576 byte(s)
Diff to previous 384
new PROOF infrastructure classes. Not yet usable. Checked in to facilitate
collaborative development with Maarten.

Revision 384 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Tue Jul 18 07:11:33 2000 UTC (14 years, 6 months ago) by brun
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2189 byte(s)
Diff to previous 382
Delete the interface functions TSelector::Executexxx. TTreePlayer::Process
calls directly the Begin, ProcessCut, etc functions.
TSelector has a new member (previously in TTree) fOption with the
GetOption and SetOption functions.

Revision 382 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Mon Jul 17 10:26:41 2000 UTC (14 years, 6 months ago) by brun
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2133 byte(s)
Diff to previous 376
TTree.h, TChain
=======
New data member  TString fProcessOption in the class TTree
This string contains the option passed to TTree::Process.
The option can be queried by TTree::GetProcessOption.

New function Int_t TTree::GetChainEntryNumber(Int_t entry)
    This function returns directly entry
New function Int_t TChain::GetChainEntryNumber(Int_t entry)
    This function returns the absolute entry number in the chain
    corresponding to the local TTree entry number entry.

The TTree::Process functions have a new optional argument Option_t (option.
same for TChain::Process, TVirtualTreePlayer and TTreePlayer

TSelector, TSelectorCint
=========
Add new functions
   virtual Bool_t      ExecuteNotify();
   virtual Bool_t      Notify() {return kTRUE;}

ExecuteNotify calls the user class function Notify when
TTree::Process starts the first entry in a file of a chain.

TTreePlayer
===========
Implememt the logic to call the new functions TSelector::ExecuteNotify

Revision 376 - (view) (download) (as text) (annotate) - [select for diffs]
Added Thu Jul 13 19:22:46 2000 UTC (14 years, 6 months ago) by brun
Original Path: trunk/tree/inc/TSelectorCint.h
File length: 2052 byte(s)
New class TSelectorCint

This form allows you to request diffs between any two revisions of this file. For each of the two "sides" of the diff, enter a numeric revision.

  Diffs between and
  Type of Diff should be a

Sort log by:

Subversion Admin
ViewVC Help
Powered by ViewVC 1.0.9