Logo ROOT  
Reference Guide
TLeaf.h
Go to the documentation of this file.
1// @(#)root/tree:$Id$
2// Author: Rene Brun 12/01/96
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#ifndef ROOT_TLeaf
13#define ROOT_TLeaf
14
15
16//////////////////////////////////////////////////////////////////////////
17// //
18// TLeaf //
19// //
20// A TTree object is a list of TBranch. //
21// A TBranch object is a list of TLeaf. In most cases, the TBranch //
22// will have one TLeaf. //
23// A TLeaf describes the branch data types and holds the data. //
24// //
25// A few notes about the data held by the leaf. It can contain: //
26// 1 a single object or primitive (e.g., one float), //
27// 2 a fixed-number of objects (e.g., each entry has two floats). //
28// The number of elements per entry is saved in `fLen`. //
29// 3 a dynamic number of primitives. The number of objects in each //
30// entry is saved in the `fLeafCount` branch. //
31// //
32// Note options (2) and (3) can combined - if fLeafCount says an entry //
33// has 3 elements and fLen is 2, then there will be 6 objects in that //
34// entry. //
35// //
36// Additionally, `fNdata` is transient and generated on read to //
37// determine the necessary size of a buffer to hold event data; //
38// depending on the call-site, it may be sized larger than the number //
39// of elements //
40// //
41//////////////////////////////////////////////////////////////////////////
42
43
44#include "TBranch.h"
45
46class TClonesArray;
47class TBrowser;
48
49class TLeaf : public TNamed {
50
51private:
52
53 virtual Int_t GetOffsetHeaderSize() const {return 0;}
54
55protected:
56
57 using Counts_t = std::vector<Int_t>;
60 Long64_t fStartEntry{-1}; ///<! entry number of corresponding to element 0 of the vector.
61 };
62
63 Int_t fNdata; ///<! Number of elements in fAddress data buffer.
64 Int_t fLen; ///< Number of fixed length elements in the leaf's data.
65 Int_t fLenType; ///< Number of bytes for this data type
66 Int_t fOffset; ///< Offset in ClonesArray object (if one)
67 Bool_t fIsRange; ///< (=kTRUE if leaf has a range, kFALSE otherwise). This is equivalent to being a 'leafcount'. For a TLeafElement the range information is actually store in the TBranchElement.
68 Bool_t fIsUnsigned; ///< (=kTRUE if unsigned, kFALSE otherwise)
69 TLeaf *fLeafCount; ///< Pointer to Leaf count if variable length (we do not own the counter)
70 TBranch *fBranch; ///<! Pointer to supporting branch (we do not own the branch)
71 LeafCountValues *fLeafCountValues; ///<! Cache of collection/array sizes
72
73 TLeaf(const TLeaf&);
74 TLeaf& operator=(const TLeaf&);
75
76 template <typename T> struct GetValueHelper {
77 static T Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetValue(i); }
78 };
79
80 Int_t *GenerateOffsetArrayBase(Int_t base, Int_t events) const; // For leaves containing fixed-size objects (no
81 // polymorphism!), this will generate an appropriate
82 // offset array.
83
84
85public:
87 kIndirectAddress = BIT(11), ///< Data member is a pointer to an array of basic types.
88 kNewValue = BIT(12) ///< Set if we own the value buffer and so must delete it ourselves.
89 };
90
91 enum class DeserializeType {
92 kInvalid = 0, // Invalid deserialization information.
93 kDestructive, // Deserialization of this Leaf requires a separate output buffer.
94 kInPlace, // Deserialization can be done directly in the input buffer.
95 kZeroCopy, // In-memory and on-disk representation of this object are identical.
96 };
97
98 TLeaf();
99 TLeaf(TBranch *parent, const char *name, const char *type);
100 virtual ~TLeaf();
101
102 virtual void Browse(TBrowser *b);
103 virtual Bool_t CanGenerateOffsetArray() {return fLeafCount;} // overload and return true if this leaf can generate its own offset array.
104 virtual void Export(TClonesArray *, Int_t) {}
105 virtual void FillBasket(TBuffer &b);
106 virtual Int_t *GenerateOffsetArray(Int_t base, Int_t events) { return GenerateOffsetArrayBase(base, events); }
107 TBranch *GetBranch() const { return fBranch; }
109 virtual TString GetFullName() const;
110 /// If this leaf stores a variable-sized array or a multi-dimensional array whose last dimension has variable size,
111 /// return a pointer to the TLeaf that stores such size. Return a nullptr otherwise.
112 virtual TLeaf *GetLeafCount() const { return fLeafCount; }
113 virtual TLeaf *GetLeafCounter(Int_t &countval) const;
114
115 virtual const Counts_t *GetLeafCountValues(Long64_t start, Long64_t len);
116
117 virtual Int_t GetLen() const;
118 /// Return the fixed length of this leaf.
119 /// If the leaf stores a fixed-length array, this is the size of the array.
120 /// If the leaf stores a non-array or a variable-sized array, this method returns 1.
121 /// If the leaf stores an array with 2 or more dimensions, this method returns the total number of elements in the
122 /// dimensions with static length: for example for float[3][2][] it would return 6.
123 virtual Int_t GetLenStatic() const { return fLen; }
124 virtual Int_t GetLenType() const { return fLenType; }
125 virtual Int_t GetMaximum() const { return 0; }
126 virtual Int_t GetMinimum() const { return 0; }
127 virtual Int_t GetNdata() const { return fNdata; }
128 virtual Int_t GetOffset() const { return fOffset; }
129 virtual void *GetValuePointer() const { return 0; }
130 virtual const char *GetTypeName() const { return ""; }
131
132 virtual Double_t GetValue(Int_t i = 0) const;
133 virtual Long64_t GetValueLong64(Int_t i = 0) const { return GetValue(i); } // overload only when it matters.
134 virtual LongDouble_t GetValueLongDouble(Int_t i = 0) const { return GetValue(i); } // overload only when it matters.
135 template <typename T> T GetTypedValue(Int_t i = 0) const { return GetValueHelper<T>::Exec(this, i); }
136
137 virtual Bool_t IncludeRange(TLeaf *) { return kFALSE; } // overload to copy/set fMinimum and fMaximum to include/be wide than those of the parameter
138 virtual void Import(TClonesArray *, Int_t) {}
139 virtual Bool_t IsOnTerminalBranch() const { return kTRUE; }
140 virtual Bool_t IsRange() const { return fIsRange; }
141 virtual Bool_t IsUnsigned() const { return fIsUnsigned; }
142 virtual void PrintValue(Int_t i = 0) const;
143 virtual void ReadBasket(TBuffer &) {}
145 virtual bool ReadBasketFast(TBuffer&, Long64_t) { return false; } // Read contents of leaf into a user-provided buffer.
146 virtual bool ReadBasketSerialized(TBuffer&, Long64_t) { return false; } // Read contents of leaf into a user-provided buffer
147 virtual void ReadValue(std::istream & /*s*/, Char_t /*delim*/ = ' ') {
148 Error("ReadValue", "Not implemented!");
149 }
150 Int_t ResetAddress(void *add, Bool_t destructor = kFALSE);
151 virtual void SetAddress(void *add = 0);
152 virtual void SetBranch(TBranch *branch) { fBranch = branch; }
153 virtual void SetLeafCount(TLeaf *leaf);
154 virtual void SetLen(Int_t len = 1) { fLen = len; }
155 virtual void SetOffset(Int_t offset = 0) { fOffset = offset; }
156 virtual void SetRange(Bool_t range = kTRUE) { fIsRange = range; }
157 virtual void SetUnsigned() { fIsUnsigned = kTRUE; }
158
159 ClassDef(TLeaf, 2); // Leaf: description of a Branch data type
160};
161
162
163template <> struct TLeaf::GetValueHelper<Long64_t> {
164 static Long64_t Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetValueLong64(i); }
165};
166template <> struct TLeaf::GetValueHelper<ULong64_t> {
167 static ULong64_t Exec(const TLeaf *leaf, Int_t i = 0) { return (ULong64_t)leaf->GetValueLong64(i); }
168};
170 static LongDouble_t Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetValueLongDouble(i); }
171};
172
173
174inline Double_t TLeaf::GetValue(Int_t /*i = 0*/) const { return 0.0; }
175inline void TLeaf::PrintValue(Int_t /* i = 0*/) const {}
176inline void TLeaf::SetAddress(void* /* add = 0 */) {}
177
178#endif
#define b(i)
Definition: RSha256.hxx:100
int Int_t
Definition: RtypesCore.h:43
char Char_t
Definition: RtypesCore.h:31
const Bool_t kFALSE
Definition: RtypesCore.h:90
bool Bool_t
Definition: RtypesCore.h:61
double Double_t
Definition: RtypesCore.h:57
long double LongDouble_t
Definition: RtypesCore.h:59
long long Long64_t
Definition: RtypesCore.h:71
unsigned long long ULong64_t
Definition: RtypesCore.h:72
const Bool_t kTRUE
Definition: RtypesCore.h:89
#define ClassDef(name, id)
Definition: Rtypes.h:322
#define BIT(n)
Definition: Rtypes.h:83
char name[80]
Definition: TGX11.cxx:109
int type
Definition: TGX11.cxx:120
A TTree is a list of TBranches.
Definition: TBranch.h:91
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
Buffer base class used for serializing objects.
Definition: TBuffer.h:42
An array of clone (identical) objects.
Definition: TClonesArray.h:32
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:49
virtual Double_t GetValue(Int_t i=0) const
Definition: TLeaf.h:174
virtual void * GetValuePointer() const
Definition: TLeaf.h:129
virtual Bool_t IsRange() const
Definition: TLeaf.h:140
Int_t fLenType
Number of bytes for this data type.
Definition: TLeaf.h:65
virtual bool ReadBasketSerialized(TBuffer &, Long64_t)
Definition: TLeaf.h:146
virtual void SetLen(Int_t len=1)
Definition: TLeaf.h:154
virtual const Counts_t * GetLeafCountValues(Long64_t start, Long64_t len)
If this branch is a branch count, return the set of collection size for the entry range requested sta...
Definition: TLeaf.cxx:342
virtual Bool_t IsOnTerminalBranch() const
Definition: TLeaf.h:139
virtual Int_t GetLenType() const
Definition: TLeaf.h:124
T GetTypedValue(Int_t i=0) const
Definition: TLeaf.h:135
virtual void ReadValue(std::istream &, Char_t=' ')
Definition: TLeaf.h:147
virtual Int_t GetMaximum() const
Definition: TLeaf.h:125
virtual const char * GetTypeName() const
Definition: TLeaf.h:130
virtual LongDouble_t GetValueLongDouble(Int_t i=0) const
Definition: TLeaf.h:134
virtual void Browse(TBrowser *b)
Browse the content of this leaf.
Definition: TLeaf.cxx:135
Int_t fLen
Number of fixed length elements in the leaf's data.
Definition: TLeaf.h:64
Int_t fNdata
! Number of elements in fAddress data buffer.
Definition: TLeaf.h:63
virtual Int_t GetLen() const
Return the number of effective elements of this leaf, for the current entry.
Definition: TLeaf.cxx:382
virtual TLeaf * GetLeafCount() const
If this leaf stores a variable-sized array or a multi-dimensional array whose last dimension has vari...
Definition: TLeaf.h:112
virtual Bool_t IncludeRange(TLeaf *)
Definition: TLeaf.h:137
virtual void Export(TClonesArray *, Int_t)
Definition: TLeaf.h:104
virtual DeserializeType GetDeserializeType() const
Definition: TLeaf.h:108
virtual void ReadBasketExport(TBuffer &, TClonesArray *, Int_t)
Definition: TLeaf.h:144
Bool_t fIsUnsigned
(=kTRUE if unsigned, kFALSE otherwise)
Definition: TLeaf.h:68
virtual ~TLeaf()
Destructor.
Definition: TLeaf.cxx:118
TLeaf & operator=(const TLeaf &)
Assignment operator.
Definition: TLeaf.cxx:95
virtual void SetAddress(void *add=0)
Definition: TLeaf.h:176
virtual TLeaf * GetLeafCounter(Int_t &countval) const
Return a pointer to the counter of this leaf (if any) or store the number of elements that the leaf c...
Definition: TLeaf.cxx:227
DeserializeType
Definition: TLeaf.h:91
virtual Long64_t GetValueLong64(Int_t i=0) const
Definition: TLeaf.h:133
virtual void SetRange(Bool_t range=kTRUE)
Definition: TLeaf.h:156
Int_t * GenerateOffsetArrayBase(Int_t base, Int_t events) const
If the class supports it, generate an offset array base.
Definition: TLeaf.cxx:166
virtual Int_t GetNdata() const
Definition: TLeaf.h:127
virtual void FillBasket(TBuffer &b)
Pack leaf elements in Basket output buffer.
Definition: TLeaf.cxx:158
TLeaf()
Definition: TLeaf.cxx:33
TBranch * GetBranch() const
Definition: TLeaf.h:107
virtual void SetOffset(Int_t offset=0)
Definition: TLeaf.h:155
Int_t fOffset
Offset in ClonesArray object (if one)
Definition: TLeaf.h:66
virtual bool ReadBasketFast(TBuffer &, Long64_t)
Definition: TLeaf.h:145
virtual Int_t GetOffsetHeaderSize() const
Definition: TLeaf.h:53
virtual Int_t GetMinimum() const
Definition: TLeaf.h:126
TBranch * fBranch
! Pointer to supporting branch (we do not own the branch)
Definition: TLeaf.h:70
TLeaf * fLeafCount
Pointer to Leaf count if variable length (we do not own the counter)
Definition: TLeaf.h:69
virtual void SetBranch(TBranch *branch)
Definition: TLeaf.h:152
Bool_t fIsRange
(=kTRUE if leaf has a range, kFALSE otherwise). This is equivalent to being a 'leafcount'....
Definition: TLeaf.h:67
@ kNewValue
Set if we own the value buffer and so must delete it ourselves.
Definition: TLeaf.h:88
@ kIndirectAddress
Data member is a pointer to an array of basic types.
Definition: TLeaf.h:87
virtual void SetLeafCount(TLeaf *leaf)
Set the leaf count of this leaf.
Definition: TLeaf.cxx:443
virtual void SetUnsigned()
Definition: TLeaf.h:157
virtual TString GetFullName() const
Return the full name (including the parent's branch names) of the leaf.
Definition: TLeaf.cxx:202
virtual Int_t GetLenStatic() const
Return the fixed length of this leaf.
Definition: TLeaf.h:123
virtual Bool_t CanGenerateOffsetArray()
Definition: TLeaf.h:103
virtual Int_t GetOffset() const
Definition: TLeaf.h:128
virtual Bool_t IsUnsigned() const
Definition: TLeaf.h:141
virtual void ReadBasket(TBuffer &)
Definition: TLeaf.h:143
LeafCountValues * fLeafCountValues
! Cache of collection/array sizes
Definition: TLeaf.h:71
virtual Int_t * GenerateOffsetArray(Int_t base, Int_t events)
Definition: TLeaf.h:106
std::vector< Int_t > Counts_t
Definition: TLeaf.h:57
virtual void Import(TClonesArray *, Int_t)
Definition: TLeaf.h:138
Int_t ResetAddress(void *add, Bool_t destructor=kFALSE)
Helper routine for TLeafX::SetAddress.
Definition: TLeaf.cxx:407
virtual void PrintValue(Int_t i=0) const
Definition: TLeaf.h:175
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:891
EStatusBits
Definition: TObject.h:57
Basic string class.
Definition: TString.h:131
double T(double x)
Definition: ChebyshevPol.h:34
static Long64_t Exec(const TLeaf *leaf, Int_t i=0)
Definition: TLeaf.h:164
static LongDouble_t Exec(const TLeaf *leaf, Int_t i=0)
Definition: TLeaf.h:170
static ULong64_t Exec(const TLeaf *leaf, Int_t i=0)
Definition: TLeaf.h:167
static T Exec(const TLeaf *leaf, Int_t i=0)
Definition: TLeaf.h:77
Counts_t fValues
Definition: TLeaf.h:59
Long64_t fStartEntry
! entry number of corresponding to element 0 of the vector.
Definition: TLeaf.h:60