g4tools  5.4.0
Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
tools::rroot::tree Class Reference
Inheritance diagram for tools::rroot::tree:
Inheritance graph
[legend]
Collaboration diagram for tools::rroot::tree:
Collaboration graph
[legend]

Public Member Functions

virtual const std::string & s_cls () const
 
virtual const std::string & name () const
 
virtual const std::string & title () const
 
virtual const std::string & store_class_name () const
 
 tree (ifile &a_file, ifac &a_fac)
 
virtual ~tree ()
 
std::ostream & out () const
 
ifile & file ()
 
ifac & fac ()
 
const std::vector< branch * > & branches () const
 
bool find_entry (uint64 a_entry, uint32 &a_nbytes)
 
void dump (std::ostream &a_out, const std::string &a_spaces="", const std::string &a_indent=" ")
 
branch * find_branch (const std::string &a_name, bool a_recursive=false) const
 
branch_element * find_branch_element (const std::string &a_name, bool a_recursive=false) const
 
base_leaf * find_leaf (const std::string &a_name, bool a_recursive=false) const
 
void find_leaves (std::vector< base_leaf * > &a_leaves) const
 
void find_branches (std::vector< branch * > &a_branches) const
 
branch * find_leaf_branch (const base_leaf &a_leaf) const
 
bool show (std::ostream &a_out, uint64 a_entry)
 
uint64 entries () const
 
virtual bool stream (buffer &a_buffer)
 
- Public Member Functions inherited from tools::rroot::iobject
virtual ~iobject ()
 

Static Public Member Functions

static const std::string & s_class ()
 

Protected Member Functions

 tree (const tree &a_from)
 
tree & operator= (const tree &)
 
void _dump_branches (std::ostream &a_out, const std::vector< branch * > &a_bs, const std::string &a_spaces="", const std::string &a_indent=" ")
 

Static Protected Member Functions

static branch * _find_branch (const std::vector< branch * > &a_bs, const std::string &a_name, bool a_recursive)
 
static base_leaf * _find_leaf (const std::vector< branch * > &a_bs, const std::string &a_name, bool a_recursive)
 
static void _find_leaves (const std::vector< branch * > &a_bs, std::vector< base_leaf * > &a_leaves)
 
static void _find_branches (const std::vector< branch * > &a_bs, std::vector< branch * > &a_branches)
 
static branch * _find_leaf_branch (const std::vector< branch * > &a_bs, const base_leaf &a_leaf)
 

Protected Attributes

ifile & m_file
 
ifac & m_fac
 
std::ostream & m_out
 
std::string m_name
 
std::string m_title
 
obj_array< branch > m_branches
 
uint64 m_entries
 

Detailed Description

Definition at line 20 of file tree.

Constructor & Destructor Documentation

◆ tree() [1/2]

tools::rroot::tree::tree ( ifile &  a_file,
ifac &  a_fac 
)
inline

Definition at line 35 of file tree.

36  :m_file(a_file)
37  ,m_fac(a_fac)
38  ,m_out(a_file.out())
39  ,m_name("")
40  ,m_title("")
41  ,m_branches(a_fac)
42  ,m_entries(0)
43  {
44 #ifdef TOOLS_MEM
45  mem::increment(s_class().c_str());
46 #endif
47  }

◆ ~tree()

virtual tools::rroot::tree::~tree ( )
inlinevirtual

Definition at line 48 of file tree.

48  {
49 #ifdef TOOLS_MEM
50  mem::decrement(s_class().c_str());
51 #endif
52  }

◆ tree() [2/2]

tools::rroot::tree::tree ( const tree &  a_from)
inlineprotected

Definition at line 54 of file tree.

55  :iobject(a_from)
56  ,m_file(a_from.m_file)
57  ,m_fac(a_from.m_fac)
58  ,m_out(a_from.m_out)
59  ,m_branches(m_fac)
60  {}

Member Function Documentation

◆ _dump_branches()

void tools::rroot::tree::_dump_branches ( std::ostream &  a_out,
const std::vector< branch * > &  a_bs,
const std::string &  a_spaces = "",
const std::string &  a_indent = " " 
)
inlineprotected

Definition at line 393 of file tree.

396  {
397  tools_vforcit(branch*,a_bs,it) {
398  if(branch_element* be = safe_cast<branch,branch_element>(*(*it))) {
399  a_out << a_spaces
400  << "branch_element :"
401  << " name=" << sout((*it)->name())
402  << " title=" << sout((*it)->title())
403  << " entry_number=" << be->entry_number()
404  << " ref_cls=" << sout(be->class_name())
405  << " (type=" << be->type()
406  << ",id=" << be->id()
407  << ",stype=" << be->streamer_type()
408  << ")."
409  << std::endl;
410  } else {
411  a_out << a_spaces
412  << "branch :"
413  << " name=" << sout((*it)->name())
414  << " title=" << sout((*it)->title())
415  << " entry_number=" << (*it)->entry_number()
416  << std::endl;
417  }
418 
419 
420  {const std::vector<base_leaf*>& lvs = (*it)->leaves();
421  tools_vforcit(base_leaf*,lvs,itl) {
422  a_out << a_spaces << a_indent
423  << "leave :"
424  << " name=" << sout((*itl)->name())
425  << " title=" << sout((*itl)->title())
426  << " cls=" << sout((*itl)->s_cls())
427  << std::endl;
428  }}
429 
430  _dump_branches(a_out,(*it)->branches(),a_spaces+a_indent,a_indent);
431  }
432  }

◆ _find_branch()

static branch* tools::rroot::tree::_find_branch ( const std::vector< branch * > &  a_bs,
const std::string &  a_name,
bool  a_recursive 
)
inlinestaticprotected

Definition at line 434 of file tree.

434  {
435  tools_vforcit(branch*,a_bs,it) {
436  if(rcmp((*it)->name(),a_name)) return *it;
437  if(a_recursive) {
438  branch* br = _find_branch((*it)->branches(),a_name,a_recursive);
439  if(br) return br;
440  }
441  }
442  return 0;
443  }

◆ _find_branches()

static void tools::rroot::tree::_find_branches ( const std::vector< branch * > &  a_bs,
std::vector< branch * > &  a_branches 
)
inlinestaticprotected

Definition at line 465 of file tree.

465  {
466  tools_vforcit(branch*,a_bs,it) {
467  a_branches.push_back(*it);
468  _find_branches((*it)->branches(),a_branches);
469  }
470  }

◆ _find_leaf()

static base_leaf* tools::rroot::tree::_find_leaf ( const std::vector< branch * > &  a_bs,
const std::string &  a_name,
bool  a_recursive 
)
inlinestaticprotected

Definition at line 445 of file tree.

445  {
446  tools_vforcit(branch*,a_bs,it) {
447  tools_vforcit(base_leaf*,(*it)->leaves(),itl) {
448  if(rcmp((*itl)->name(),a_name)) return *itl;
449  }
450  if(a_recursive) {
451  base_leaf* lf = _find_leaf((*it)->branches(),a_name,a_recursive);
452  if(lf) return lf;
453  }
454  }
455  return 0;
456  }

◆ _find_leaf_branch()

static branch* tools::rroot::tree::_find_leaf_branch ( const std::vector< branch * > &  a_bs,
const base_leaf &  a_leaf 
)
inlinestaticprotected

Definition at line 472 of file tree.

472  {
473  tools_vforcit(branch*,a_bs,itb) {
474  tools_vforcit(base_leaf*,(*itb)->leaves(),itl) {if(*itl==&a_leaf) return *itb;}
475  {branch* br = _find_leaf_branch((*itb)->branches(),a_leaf);
476  if(br) return br;}
477  }
478  return 0;
479  }

◆ _find_leaves()

static void tools::rroot::tree::_find_leaves ( const std::vector< branch * > &  a_bs,
std::vector< base_leaf * > &  a_leaves 
)
inlinestaticprotected

Definition at line 458 of file tree.

458  {
459  tools_vforcit(branch*,a_bs,it) {
460  tools_vforcit(base_leaf*,(*it)->leaves(),itl) a_leaves.push_back(*itl);
461  _find_leaves((*it)->branches(),a_leaves);
462  }
463  }

◆ branches()

const std::vector<branch*>& tools::rroot::tree::branches ( ) const
inline

Definition at line 68 of file tree.

68 {return m_branches;}

◆ dump()

void tools::rroot::tree::dump ( std::ostream &  a_out,
const std::string &  a_spaces = "",
const std::string &  a_indent = " " 
)
inline

Definition at line 84 of file tree.

84  {
85  a_out << a_spaces
86  << "tree :"
87  << " name=" << sout(m_name)
88  << " title=" << sout(m_title)
89  << " entries=" << m_entries
90  << std::endl;
91  _dump_branches(a_out,m_branches,a_spaces+a_indent,a_indent);
92  }

◆ entries()

uint64 tools::rroot::tree::entries ( ) const
inline

Definition at line 128 of file tree.

128 {return m_entries;}

◆ fac()

ifac& tools::rroot::tree::fac ( )
inline

Definition at line 66 of file tree.

66 {return m_fac;}

◆ file()

ifile& tools::rroot::tree::file ( )
inline

Definition at line 65 of file tree.

65 {return m_file;}

◆ find_branch()

branch* tools::rroot::tree::find_branch ( const std::string &  a_name,
bool  a_recursive = false 
) const
inline

Definition at line 94 of file tree.

94  {
95  return _find_branch(m_branches,a_name,a_recursive);
96  }

◆ find_branch_element()

branch_element* tools::rroot::tree::find_branch_element ( const std::string &  a_name,
bool  a_recursive = false 
) const
inline

Definition at line 98 of file tree.

98  {
99  branch* b = _find_branch(m_branches,a_name,a_recursive);
100  if(!b) return 0;
101  return id_cast<branch,branch_element>(*b);
102  }

◆ find_branches()

void tools::rroot::tree::find_branches ( std::vector< branch * > &  a_branches) const
inline

Definition at line 113 of file tree.

113  {
114  a_branches.clear();
115  _find_branches(m_branches,a_branches);
116  }

◆ find_entry()

bool tools::rroot::tree::find_entry ( uint64  a_entry,
uint32 &  a_nbytes 
)
inline

Definition at line 70 of file tree.

70  {
71  a_nbytes = 0;
72  if(a_entry>=m_entries) return false;
73  int nbytes = 0;
74  //fReadEntry = a_entry;
75  tools_vforit(branch*,m_branches,it) {
76  uint32 n;
77  if(!(*it)->find_entry(m_file,a_entry,n)) return false;
78  nbytes += n;
79  }
80  a_nbytes = nbytes;
81  return true;
82  }

◆ find_leaf()

base_leaf* tools::rroot::tree::find_leaf ( const std::string &  a_name,
bool  a_recursive = false 
) const
inline

Definition at line 104 of file tree.

104  {
105  return _find_leaf(m_branches,a_name,a_recursive);
106  }

◆ find_leaf_branch()

branch* tools::rroot::tree::find_leaf_branch ( const base_leaf &  a_leaf) const
inline

Definition at line 118 of file tree.

118 {return _find_leaf_branch(m_branches,a_leaf);}

◆ find_leaves()

void tools::rroot::tree::find_leaves ( std::vector< base_leaf * > &  a_leaves) const
inline

Definition at line 108 of file tree.

108  {
109  a_leaves.clear();
110  _find_leaves(m_branches,a_leaves);
111  }

◆ name()

virtual const std::string& tools::rroot::tree::name ( ) const
inlinevirtual

Implements tools::rroot::iobject.

Definition at line 28 of file tree.

28 {return m_name;}

◆ operator=()

tree& tools::rroot::tree::operator= ( const tree &  )
inlineprotected

Definition at line 61 of file tree.

61 {return *this;}

◆ out()

std::ostream& tools::rroot::tree::out ( ) const
inline

Definition at line 63 of file tree.

63 {return m_out;}

◆ s_class()

static const std::string& tools::rroot::tree::s_class ( )
inlinestatic

Definition at line 22 of file tree.

22  {
23  static const std::string s_v("tools::rroot::tree");
24  return s_v;
25  }

◆ s_cls()

virtual const std::string& tools::rroot::tree::s_cls ( ) const
inlinevirtual

Definition at line 26 of file tree.

26 {return s_class();}

◆ show()

bool tools::rroot::tree::show ( std::ostream &  a_out,
uint64  a_entry 
)
inline

Definition at line 120 of file tree.

120  {
121  a_out << "======> EVENT:" << a_entry << std::endl;
122  tools_vforit(branch*,m_branches,it) {
123  if(!(*it)->show(a_out,m_file,a_entry)) return false;
124  }
125  return true;
126  }

◆ store_class_name()

virtual const std::string& tools::rroot::tree::store_class_name ( ) const
inlinevirtual

Implements tools::rroot::iobject.

Definition at line 30 of file tree.

30  {
31  static const std::string s_v("TTree");
32  return s_v;
33  }

◆ stream()

virtual bool tools::rroot::tree::stream ( buffer &  a_buffer)
inlinevirtual

<[fNClusterRange] Last entry of a cluster range.

<[fNClusterRange] Number of entries in each cluster for a given range.

Implements tools::rroot::iobject.

Definition at line 130 of file tree.

130  { //virtual for iobject.
131  //uint64 m_tot_bytes;
132  //uint64 m_zip_bytes;
133  //uint64 m_saved_bytes;
134 
135  short vers;
136  unsigned int s, c;
137  if(!a_buffer.read_version(vers,s,c)) return false;
138 
139  //::printf("debug : tree::stream : version %d count %d\n",vers,c);
140 
141  //if (vers > 4) {
142  //TTree::Class()->ReadBuffer(b, this, vers, s, c);
143  //if (fEstimate <= 10000) fEstimate = 1000000;
144  //m_saved_bytes = m_tot_bytes;
145  //fDirectory = gDirectory;
146  //gDirectory->Append(this);
147  //return;
148  //}
149 
150  if(!Named_stream(a_buffer,m_name,m_title)) return false;
151 
152  {short color,style,width;
153  if(!AttLine_stream(a_buffer,color,style,width)) return false;}
154  {short color,style;
155  if(!AttFill_stream(a_buffer,color,style)) return false;}
156  if(!AttMarker_stream(a_buffer)) return false;
157 
158  if(vers<=4) {
159  int dummy_int;
160 
161  if(!a_buffer.read(dummy_int)) return false; //fScanField
162  if(!a_buffer.read(dummy_int)) return false; //fMaxEntryLoop
163  {int fMaxVirtualSize;
164  if(!a_buffer.read(fMaxVirtualSize)) return false;}
165  {double v;
166  if(!a_buffer.read(v)) return false;
167  m_entries = uint64(v);}
168  {double v;
169  if(!a_buffer.read(v)) return false;
170  //m_tot_bytes = uint64(v);
171  }
172  {double v;
173  if(!a_buffer.read(v)) return false;
174  //m_zip_bytes = uint64(v);
175  }
176  {int fAutoSave;
177  if(!a_buffer.read(fAutoSave)) return false;}
178  if(!a_buffer.read(dummy_int)) return false; //fEstimate
179 
180  } else if(vers<=9) {
181  {double v;
182  if(!a_buffer.read(v)) return false;
183  m_entries = uint64(v);}
184  {double v;
185  if(!a_buffer.read(v)) return false;
186  //m_tot_bytes = uint64(v);
187  }
188  {double v;
189  if(!a_buffer.read(v)) return false;
190  //m_zip_bytes = uint64(v);
191  }
192  {double v;
193  if(!a_buffer.read(v)) return false;
194  //m_saved_bytes = uint64(v);
195  }
196 
197  int dummy_int;
198  if(!a_buffer.read(dummy_int)) return false; //fTimerInterval
199  if(!a_buffer.read(dummy_int)) return false; //fScanField
200  if(!a_buffer.read(dummy_int)) return false; //fUpdate
201  if(!a_buffer.read(dummy_int)) return false; //fMaxEntryLoop
202 
203  {int fMaxVirtualSize;
204  if(!a_buffer.read(fMaxVirtualSize)) return false;}
205  {int fAutoSave;
206  if(!a_buffer.read(fAutoSave)) return false;}
207  if(!a_buffer.read(dummy_int)) return false; //fEstimate
208 
209  } else if(vers<16) { //FIXME : what is the exact version ?
210  double dummy_double;
211  int dummy_int;
212 
213  {double v;
214  if(!a_buffer.read(v)) return false;
215  m_entries = uint64(v);}
216  {double v;
217  if(!a_buffer.read(v)) return false;
218  //m_tot_bytes = uint64(v);
219  }
220  {double v;
221  if(!a_buffer.read(v)) return false;
222  //m_zip_bytes = uint64(v);
223  }
224  {double v;
225  if(!a_buffer.read(v)) return false;
226  //m_saved_bytes = uint64(v);
227  }
228  if(!a_buffer.read(dummy_double)) return false; //fWeight
229  if(!a_buffer.read(dummy_int)) return false; //fTimerInterval
230  if(!a_buffer.read(dummy_int)) return false; //fScanField
231  if(!a_buffer.read(dummy_int)) return false; //fUpdate
232  if(!a_buffer.read(dummy_int)) return false; //fMaxEntryLoop
233 
234  {int fMaxVirtualSize;
235  if(!a_buffer.read(fMaxVirtualSize)) return false;}
236  {int fAutoSave;
237  if(!a_buffer.read(fAutoSave)) return false;}
238  if(!a_buffer.read(dummy_int)) return false; //fEstimate
239 
240  } else { //vers>=16
241  double dummy_double;
242  int dummy_int;
243  int64 dummy_int64;
244 
245  {uint64 v;
246  if(!a_buffer.read(v)) return false;
247  m_entries = v;}
248  {uint64 v;
249  if(!a_buffer.read(v)) return false;
250  //m_tot_bytes = v;
251  }
252  {uint64 v;
253  if(!a_buffer.read(v)) return false;
254  //m_zip_bytes = v;
255  }
256  {uint64 v;
257  if(!a_buffer.read(v)) return false;
258  //m_saved_bytes = v;
259  }
260  if(vers>=18) {
261  if(!a_buffer.read(dummy_int64)) return false; //fFlushedBytes
262  }
263 
264  if(!a_buffer.read(dummy_double)) return false; //fWeight
265 
266  if(!a_buffer.read(dummy_int)) return false; //fTimerInterval
267  if(!a_buffer.read(dummy_int)) return false; //fScanField
268  if(!a_buffer.read(dummy_int)) return false; //fUpdate
269 
270  if(vers>=18) {
271  if(!a_buffer.read(dummy_int)) return false; //fDefaultEntryOffsetLen
272  }
273  int fNClusterRange;
274  if(vers>=20) {
275  if(!a_buffer.read(fNClusterRange)) return false; //fNClusterRange
276  }
277 
278  if(!a_buffer.read(dummy_int64)) return false; //fMaxEntries
279  if(!a_buffer.read(dummy_int64)) return false; //fMaxEntryLoop
280  {uint64 fMaxVirtualSize;
281  if(!a_buffer.read(fMaxVirtualSize)) return false;}
282  {uint64 fAutoSave;
283  if(!a_buffer.read(fAutoSave)) return false;}
284  if(vers>=18) {
285  if(!a_buffer.read(dummy_int64)) return false; //fAutoFlush
286  }
287  if(!a_buffer.read(dummy_int64)) return false; //fEstimate
288  if(vers>=20) {
289  int64* fClusterRangeEnd = 0;
290  if(!fixed_array_stream<int64>(a_buffer,fNClusterRange,fClusterRangeEnd)) return false;
291  delete [] fClusterRangeEnd;
292  int64* fClusterSize = 0;
293  if(!fixed_array_stream<int64>(a_buffer,fNClusterRange,fClusterSize)) return false;
294  delete [] fClusterSize;
295  dummy _dummy;
296  if(!_dummy.stream(a_buffer)) { //TIOFeatures fIOFeatures
297  m_out << "tools::rroot::tree::stream : can't read (dummy) TIOFeatures." << std::endl;
298  return false;
299  }
300  }
301  }
302 
303  //FIXME if (fEstimate <= 10000) fEstimate = 1000000;
304 
305  //TObjArray
306  //The below m_branches.read will create leaves.
307  //::printf("debug : tree : read branches : begin\n");
308  {ifac::args args;
309  if(!m_branches.stream(a_buffer,args)) {
310  m_out << "tools::rroot::tree::stream : "
311  << "can't read branches."
312  << std::endl;
313  return false;
314  }}
315  //::printf("debug : tree : read branches : end\n");
316 
317  //TObjArray
318  // We read leaves in order to keep streaming synchronisation.
319  // In fact m_leaves are references to existing leaves read by
320  // the branches in the upper line of code.
321  //::printf("debug : tree : read leaves : begin\n");
322  {obj_array<base_leaf> m_leaves(m_fac);
323  //branch b(m_out,m_fac);
324  ifac::args args;
325  //args[ifac::arg_branch()] = &b;
326  if(!m_leaves.stream(a_buffer,args)) {
327  m_out << "tools::rroot::tree::stream : "
328  << "can't read leaves."
329  << std::endl;
330  return false;
331  }}
332  //::printf("debug : tree : read leaves : end\n");
333 
334  if(vers>=10) {
335  //TList* fAliases
336  if(!dummy_TXxx_pointer_stream(a_buffer,m_fac)) {
337  m_out << "tools::rroot::tree::stream : "
338  << "can't read fAliases."
339  << std::endl;
340  return false;
341  }
342  }
343 
344  //m_saved_bytes = m_tot_bytes;
345  {std::vector<double> v;
346  if(!Array_stream<double>(a_buffer,v)) return false;} //fIndexValues TArrayD
347 
348  {std::vector<int> v;
349  if(!Array_stream<int>(a_buffer,v)) return false;} // fIndex (TArrayI).
350 
351  if(vers>=16) {
352  //TVirtualIndex* fTreeIndex //FIXME ???
353  if(!dummy_TXxx_pointer_stream(a_buffer,m_fac)) {
354  m_out << "tools::rroot::tree::stream : "
355  << "can't read fTreeIndex."
356  << std::endl;
357  return false;
358  }
359  }
360 
361  if(vers>=6) {
362  //TList* fFriends
363  if(!dummy_TXxx_pointer_stream(a_buffer,m_fac)) {
364  m_out << "tools::rroot::tree::stream : "
365  << "can't read fFriends."
366  << std::endl;
367  return false;
368  }
369  }
370 
371  if(vers>=16) {
372  //TList* fUserInfo
373  if(!dummy_TXxx_pointer_stream(a_buffer,m_fac)) {
374  m_out << "tools::rroot::tree::stream : "
375  << "can't read fUserInfo."
376  << std::endl;
377  return false;
378  }
379  //TBranchRef* fBranchRef
380  if(!dummy_TXxx_pointer_stream(a_buffer,m_fac)) {
381  m_out << "tools::rroot::tree::stream : "
382  << "can't read fBranchRef."
383  << std::endl;
384  return false;
385  }
386  }
387 
388  if(!a_buffer.check_byte_count(s,c,TTree_cls())) return false;
389 
390  return true;
391  }

◆ title()

virtual const std::string& tools::rroot::tree::title ( ) const
inlinevirtual

Implements tools::rroot::iobject.

Definition at line 29 of file tree.

29 {return m_title;}

Member Data Documentation

◆ m_branches

obj_array<branch> tools::rroot::tree::m_branches
protected

Definition at line 488 of file tree.

◆ m_entries

uint64 tools::rroot::tree::m_entries
protected

Definition at line 489 of file tree.

◆ m_fac

ifac& tools::rroot::tree::m_fac
protected

Definition at line 482 of file tree.

◆ m_file

ifile& tools::rroot::tree::m_file
protected

Definition at line 481 of file tree.

◆ m_name

std::string tools::rroot::tree::m_name
protected

Definition at line 485 of file tree.

◆ m_out

std::ostream& tools::rroot::tree::m_out
protected

Definition at line 483 of file tree.

◆ m_title

std::string tools::rroot::tree::m_title
protected

Definition at line 486 of file tree.

The documentation for this class was generated from the following file:
tools::rroot::AttMarker_stream
bool AttMarker_stream(buffer &a_buffer)
Definition: named:48
tools::rroot::tree::_find_leaf_branch
static branch * _find_leaf_branch(const std::vector< branch * > &a_bs, const base_leaf &a_leaf)
Definition: tree:472
tools::uint64
unsigned long long uint64
Definition: typedefs:72
tools::int64
long long int64
Definition: typedefs:67
tools::rroot::tree::m_out
std::ostream & m_out
Definition: tree:483
tools::rroot::tree::m_title
std::string m_title
Definition: tree:486
tools::rroot::TTree_cls
const std::string & TTree_cls()
Definition: tree:15
tools::rroot::AttLine_stream
bool AttLine_stream(buffer &a_buffer, short &a_color, short &a_style, short &a_width)
Definition: named:27
tools::rroot::tree::_find_leaves
static void _find_leaves(const std::vector< branch * > &a_bs, std::vector< base_leaf * > &a_leaves)
Definition: tree:458
tools::rroot::tree::_dump_branches
void _dump_branches(std::ostream &a_out, const std::vector< branch * > &a_bs, const std::string &a_spaces="", const std::string &a_indent=" ")
Definition: tree:393
tools::rroot::Named_stream
bool Named_stream(buffer &a_buffer, std::string &a_name, std::string &a_title)
Definition: named:15
tools::rroot::tree::s_class
static const std::string & s_class()
Definition: tree:22
tools::rroot::tree::m_entries
uint64 m_entries
Definition: tree:489
tools::rroot::tree::_find_branches
static void _find_branches(const std::vector< branch * > &a_bs, std::vector< branch * > &a_branches)
Definition: tree:465
tools::rroot::AttFill_stream
bool AttFill_stream(buffer &a_buffer, short &a_color, short &a_style)
Definition: named:38
tools::rroot::tree::m_file
ifile & m_file
Definition: tree:481
tools::rroot::tree::m_name
std::string m_name
Definition: tree:485
tools_vforit
#define tools_vforit(a__T, a__v, a__it)
Definition: forit:13
tools::rcmp
bool rcmp(const char *a_1, const char *a_2)
Definition: rcmp:14
tools::rroot::tree::m_fac
ifac & m_fac
Definition: tree:482
tools::rroot::tree::_find_branch
static branch * _find_branch(const std::vector< branch * > &a_bs, const std::string &a_name, bool a_recursive)
Definition: tree:434
tools::rroot::ifac::args
std::map< char, void * > args
Definition: ifac:21
tools_vforcit
#define tools_vforcit(a__T, a__v, a__it)
Definition: forit:7
tools::rroot::dummy_TXxx_pointer_stream
bool dummy_TXxx_pointer_stream(buffer &a_buffer, ifac &a_fac)
Definition: buffer:631
tools::uint32
unsigned int uint32
Definition: typedefs:71
tools::rroot::tree::m_branches
obj_array< branch > m_branches
Definition: tree:488
tools::rroot::tree::_find_leaf
static base_leaf * _find_leaf(const std::vector< branch * > &a_bs, const std::string &a_name, bool a_recursive)
Definition: tree:445
Generated by doxygen 1.8.20