| Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 1 // Copyright (C) 2010, Guy Barrand. All rights reserved.
2 // See the file tools.license for terms. 2 // See the file tools.license for terms.
3 3
4 #ifndef tools_rroot_ntuple 4 #ifndef tools_rroot_ntuple
5 #define tools_rroot_ntuple 5 #define tools_rroot_ntuple
6 6
7 // to have same API than rcsv::ntuple. 7 // to have same API than rcsv::ntuple.
8 8
9 #include "../rntuple" 9 #include "../rntuple"
10 10
11 #include "tree" 11 #include "tree"
12 #include "leaf" 12 #include "leaf"
13 #include "stl_vector" 13 #include "stl_vector"
14 14
15 #include "../cids" 15 #include "../cids"
16 #include "../vfind" 16 #include "../vfind"
17 #include "../vmanip" 17 #include "../vmanip"
18 #include "../ntuple_binding" 18 #include "../ntuple_binding"
19 #include "../get_lines" 19 #include "../get_lines"
20 20
21 #ifdef TOOLS_MEM 21 #ifdef TOOLS_MEM
22 #include "../mem" 22 #include "../mem"
23 #endif 23 #endif
24 24
25 namespace tools { 25 namespace tools {
26 namespace rroot { 26 namespace rroot {
27 27
28 class ntuple : public virtual read::intuple { 28 class ntuple : public virtual read::intuple {
29 typedef read::intuple parent; 29 typedef read::intuple parent;
30 public: 30 public:
31 static const std::string& s_class() { 31 static const std::string& s_class() {
32 static const std::string s_v("tools::rroot 32 static const std::string s_v("tools::rroot::ntuple");
33 return s_v; 33 return s_v;
34 } 34 }
35 virtual const std::string& s_cls() const {re 35 virtual const std::string& s_cls() const {return s_class();}
36 public: //intuple 36 public: //intuple
37 virtual void start() {m_index = -1;} 37 virtual void start() {m_index = -1;}
38 virtual bool next() { 38 virtual bool next() {
39 m_index++; 39 m_index++;
40 if((uint64)m_index>=m_tree.entries()) retu 40 if((uint64)m_index>=m_tree.entries()) return false;
41 return true; 41 return true;
42 } 42 }
43 virtual read::icol* find_icol(const std::str 43 virtual read::icol* find_icol(const std::string& a_name){
44 return find_named<read::icol>(m_cols,a_nam 44 return find_named<read::icol>(m_cols,a_name);
45 } 45 }
46 virtual const std::vector<read::icol*>& colu 46 virtual const std::vector<read::icol*>& columns() const {return m_cols;}
47 virtual const std::string& title() const {re 47 virtual const std::string& title() const {return m_tree.title();}
48 virtual bool number_of_entries(uint64 & a_va 48 virtual bool number_of_entries(uint64 & a_value) const {a_value = m_tree.entries();return true;}
49 public: 49 public:
50 50
51 template <class T,class LEAF> 51 template <class T,class LEAF>
52 class column_ref : public virtual read::icol 52 class column_ref : public virtual read::icolumn<T> {
53 typedef read::icolumn<T> parent; 53 typedef read::icolumn<T> parent;
54 public: 54 public:
55 static cid id_class() {return 200+_cid(T() 55 static cid id_class() {return 200+_cid(T())+10000;}
56 public: //icol 56 public: //icol
57 virtual void* cast(cid a_class) const { 57 virtual void* cast(cid a_class) const {
58 if(void* p = cmp_cast<column_ref>(this,a 58 if(void* p = cmp_cast<column_ref>(this,a_class)) return p;
59 return parent::cast(a_class); 59 return parent::cast(a_class);
60 } 60 }
61 virtual cid id_cls() const {return id_clas 61 virtual cid id_cls() const {return id_class();}
62 public: //icol 62 public: //icol
63 virtual const std::string& name() const {r 63 virtual const std::string& name() const {return m_leaf.name();}
64 public: //icolumn<T> 64 public: //icolumn<T>
65 virtual bool fetch_entry() const {return _ 65 virtual bool fetch_entry() const {return _fetch_entry();}
66 virtual bool get_entry(T& a_v) const { 66 virtual bool get_entry(T& a_v) const {
67 if(!_fetch_entry()) {a_v = T();return fa 67 if(!_fetch_entry()) {a_v = T();return false;}
68 a_v = m_ref; 68 a_v = m_ref;
69 return true; 69 return true;
70 } 70 }
71 public: 71 public:
72 column_ref(ifile& a_file,branch& a_branch, 72 column_ref(ifile& a_file,branch& a_branch,LEAF& a_leaf,int64& a_index,T& a_ref)
73 :m_file(a_file) 73 :m_file(a_file)
74 ,m_branch(a_branch) 74 ,m_branch(a_branch)
75 ,m_leaf(a_leaf) 75 ,m_leaf(a_leaf)
76 ,m_index(a_index) //WARNING : we keep the 76 ,m_index(a_index) //WARNING : we keep the ref !
77 ,m_ref(a_ref) 77 ,m_ref(a_ref)
78 {} 78 {}
79 virtual ~column_ref(){} 79 virtual ~column_ref(){}
80 protected: 80 protected:
81 column_ref(const column_ref& a_from) 81 column_ref(const column_ref& a_from)
82 :read::icol(a_from) 82 :read::icol(a_from)
83 ,parent(a_from) 83 ,parent(a_from)
84 ,m_file(a_from.m_file) 84 ,m_file(a_from.m_file)
85 ,m_branch(a_from.m_branch) 85 ,m_branch(a_from.m_branch)
86 ,m_leaf(a_from.m_leaf) 86 ,m_leaf(a_from.m_leaf)
87 ,m_index(a_from.m_index) 87 ,m_index(a_from.m_index)
88 ,m_ref(a_from.m_ref) 88 ,m_ref(a_from.m_ref)
89 {} 89 {}
90 column_ref& operator=(const column_ref& a_ 90 column_ref& operator=(const column_ref& a_from){
91 if(&a_from==this) return *this; 91 if(&a_from==this) return *this;
92 return *this; 92 return *this;
93 } 93 }
94 protected: 94 protected:
95 //typedef typename LEAF::value_t value_t; 95 //typedef typename LEAF::value_t value_t;
96 bool _fetch_entry() const { 96 bool _fetch_entry() const {
97 unsigned int n; 97 unsigned int n;
98 if(!m_branch.find_entry(m_file,uint32(m_ 98 if(!m_branch.find_entry(m_file,uint32(m_index),n)) {m_ref = T();return false;}
99 if(!m_leaf.num_elem()) {m_ref = T();retu 99 if(!m_leaf.num_elem()) {m_ref = T();return true;} //it is ok. It may be a vector from a row_wise ntuple column.
100 typename LEAF::value_t _tmp; 100 typename LEAF::value_t _tmp;
101 if(!m_leaf.value(0,_tmp)) return false; 101 if(!m_leaf.value(0,_tmp)) return false;
102 m_ref = T(_tmp); 102 m_ref = T(_tmp);
103 return true; 103 return true;
104 } 104 }
105 protected: 105 protected:
106 ifile& m_file; 106 ifile& m_file;
107 branch& m_branch; 107 branch& m_branch;
108 LEAF& m_leaf; 108 LEAF& m_leaf;
109 int64& m_index; //WARNING : a ref. 109 int64& m_index; //WARNING : a ref.
110 T& m_ref; 110 T& m_ref;
111 //value_t m_tmp; 111 //value_t m_tmp;
112 }; 112 };
113 113
114 template <class T,class LEAF> 114 template <class T,class LEAF>
115 class column : public column_ref<T,LEAF> { 115 class column : public column_ref<T,LEAF> {
116 typedef column_ref<T,LEAF> parent; 116 typedef column_ref<T,LEAF> parent;
117 public: 117 public:
118 static cid id_class() {return 200+_cid(T() 118 static cid id_class() {return 200+_cid(T());}
119 public: //icol 119 public: //icol
120 virtual void* cast(cid a_class) const { 120 virtual void* cast(cid a_class) const {
121 if(void* p = cmp_cast<column>(this,a_cla 121 if(void* p = cmp_cast<column>(this,a_class)) return p;
122 return parent::cast(a_class); 122 return parent::cast(a_class);
123 } 123 }
124 virtual cid id_cls() const {return id_clas 124 virtual cid id_cls() const {return id_class();}
125 public: 125 public:
126 column(ifile& a_file,branch& a_branch,LEAF 126 column(ifile& a_file,branch& a_branch,LEAF& a_leaf,int64& a_index)
127 :parent(a_file,a_branch,a_leaf,a_index,m_v 127 :parent(a_file,a_branch,a_leaf,a_index,m_value)
128 ,m_value(T()) 128 ,m_value(T())
129 {} 129 {}
130 virtual ~column(){} 130 virtual ~column(){}
131 protected: 131 protected:
132 column(const column& a_from) 132 column(const column& a_from)
133 :read::icol(a_from) 133 :read::icol(a_from)
134 ,read::icolumn<T>(a_from) 134 ,read::icolumn<T>(a_from)
135 ,parent(a_from) 135 ,parent(a_from)
136 ,m_value(a_from.m_value) 136 ,m_value(a_from.m_value)
137 {} 137 {}
138 column& operator=(const column& a_from){ 138 column& operator=(const column& a_from){
139 if(&a_from==this) return *this; 139 if(&a_from==this) return *this;
140 m_value = a_from.m_value; 140 m_value = a_from.m_value;
141 return *this; 141 return *this;
142 } 142 }
143 public: 143 public:
144 const T& get_value() const {return m_value 144 const T& get_value() const {return m_value;}
145 protected: 145 protected:
146 T m_value; 146 T m_value;
147 }; 147 };
148 148
149 class column_string_ref : public virtual rea 149 class column_string_ref : public virtual read::icol {
150 typedef read::icol parent; 150 typedef read::icol parent;
151 public: 151 public:
152 static cid id_class() { 152 static cid id_class() {
153 static const std::string s_v; 153 static const std::string s_v;
154 return _cid(s_v)+10000; 154 return _cid(s_v)+10000;
155 } 155 }
156 public: //icol 156 public: //icol
157 virtual void* cast(cid a_class) const { 157 virtual void* cast(cid a_class) const {
158 if(void* p = cmp_cast<column_string_ref> 158 if(void* p = cmp_cast<column_string_ref>(this,a_class)) return p;
159 return 0; 159 return 0;
160 } 160 }
161 virtual cid id_cls() const {return id_clas 161 virtual cid id_cls() const {return id_class();}
162 virtual const std::string& name() const {r 162 virtual const std::string& name() const {return m_leaf.name();}
163 public: 163 public:
164 virtual bool fetch_entry() const {return _ 164 virtual bool fetch_entry() const {return _fetch_entry();}
165 public: 165 public:
166 column_string_ref(ifile& a_file,branch& a_ 166 column_string_ref(ifile& a_file,branch& a_branch,leaf_string& a_leaf,int64& a_index,std::string& a_ref)
167 :m_file(a_file) 167 :m_file(a_file)
168 ,m_branch(a_branch) 168 ,m_branch(a_branch)
169 ,m_leaf(a_leaf) 169 ,m_leaf(a_leaf)
170 ,m_index(a_index) //WARNING : we keep the 170 ,m_index(a_index) //WARNING : we keep the ref !
171 ,m_ref(a_ref) 171 ,m_ref(a_ref)
172 {} 172 {}
173 virtual ~column_string_ref(){} 173 virtual ~column_string_ref(){}
174 protected: 174 protected:
175 column_string_ref(const column_string_ref& 175 column_string_ref(const column_string_ref& a_from)
176 :parent(a_from) 176 :parent(a_from)
177 ,m_file(a_from.m_file) 177 ,m_file(a_from.m_file)
178 ,m_branch(a_from.m_branch) 178 ,m_branch(a_from.m_branch)
179 ,m_leaf(a_from.m_leaf) 179 ,m_leaf(a_from.m_leaf)
180 ,m_index(a_from.m_index) 180 ,m_index(a_from.m_index)
181 ,m_ref(a_from.m_ref) 181 ,m_ref(a_from.m_ref)
182 {} 182 {}
183 column_string_ref& operator=(const column_ 183 column_string_ref& operator=(const column_string_ref& a_from){
184 if(&a_from==this) return *this; 184 if(&a_from==this) return *this;
185 return *this; 185 return *this;
186 } 186 }
187 public: 187 public:
188 bool get_entry(std::string& a_v) const { 188 bool get_entry(std::string& a_v) const {
189 if(!_fetch_entry()) {a_v.clear();return 189 if(!_fetch_entry()) {a_v.clear();return false;}
190 a_v = m_ref; 190 a_v = m_ref;
191 return true; 191 return true;
192 } 192 }
193 protected: 193 protected:
194 bool _fetch_entry() const { 194 bool _fetch_entry() const {
195 unsigned int n; 195 unsigned int n;
196 if(!m_branch.find_entry(m_file,uint32(m_ 196 if(!m_branch.find_entry(m_file,uint32(m_index),n)) {m_ref.clear();return false;}
197 const char* _cs = m_leaf.value(); 197 const char* _cs = m_leaf.value();
198 if(!_cs) {m_ref.clear();return false;} 198 if(!_cs) {m_ref.clear();return false;}
199 m_ref = _cs; 199 m_ref = _cs;
200 return true; 200 return true;
201 } 201 }
202 protected: 202 protected:
203 ifile& m_file; 203 ifile& m_file;
204 branch& m_branch; 204 branch& m_branch;
205 leaf_string& m_leaf; 205 leaf_string& m_leaf;
206 int64& m_index; //WARNING : a ref. 206 int64& m_index; //WARNING : a ref.
207 std::string& m_ref; 207 std::string& m_ref;
208 }; 208 };
209 209
210 class column_string : public column_string_r 210 class column_string : public column_string_ref {
211 typedef column_string_ref parent; 211 typedef column_string_ref parent;
212 public: 212 public:
213 static cid id_class() { 213 static cid id_class() {
214 static const std::string s_v; 214 static const std::string s_v;
215 return _cid(s_v); 215 return _cid(s_v);
216 } 216 }
217 public: //icol 217 public: //icol
218 virtual void* cast(cid a_class) const { 218 virtual void* cast(cid a_class) const {
219 if(void* p = cmp_cast<column_string>(thi 219 if(void* p = cmp_cast<column_string>(this,a_class)) return p;
220 return parent::cast(a_class); 220 return parent::cast(a_class);
221 } 221 }
222 virtual cid id_cls() const {return id_clas 222 virtual cid id_cls() const {return id_class();}
223 virtual const std::string& name() const {r 223 virtual const std::string& name() const {return m_leaf.name();}
224 public: 224 public:
225 column_string(ifile& a_file,branch& a_bran 225 column_string(ifile& a_file,branch& a_branch,leaf_string& a_leaf,int64& a_index)
226 :parent(a_file,a_branch,a_leaf,a_index,m_v 226 :parent(a_file,a_branch,a_leaf,a_index,m_value)
227 {} 227 {}
228 virtual ~column_string(){} 228 virtual ~column_string(){}
229 protected: 229 protected:
230 column_string(const column_string& a_from) 230 column_string(const column_string& a_from)
231 :read::icol(a_from) 231 :read::icol(a_from)
232 ,parent(a_from) 232 ,parent(a_from)
233 ,m_value(a_from.m_value) 233 ,m_value(a_from.m_value)
234 {} 234 {}
235 column_string& operator=(const column_stri 235 column_string& operator=(const column_string& a_from){
236 if(&a_from==this) return *this; 236 if(&a_from==this) return *this;
237 m_value = a_from.m_value; 237 m_value = a_from.m_value;
238 return *this; 238 return *this;
239 } 239 }
240 public: 240 public:
241 const std::string& get_value() const {retu 241 const std::string& get_value() const {return m_value;}
242 protected: 242 protected:
243 std::string m_value; 243 std::string m_value;
244 }; 244 };
245 245
246 class column_vector_string_ref : public colu 246 class column_vector_string_ref : public column_string_ref {
247 typedef column_string_ref parent; 247 typedef column_string_ref parent;
248 public: 248 public:
249 static cid id_class() {return _cid_std_vec 249 static cid id_class() {return _cid_std_vector<std::string>()+10000;}
250 public: //icol 250 public: //icol
251 virtual void* cast(cid a_class) const { 251 virtual void* cast(cid a_class) const {
252 if(void* p = cmp_cast<column_vector_stri 252 if(void* p = cmp_cast<column_vector_string_ref>(this,a_class)) return p;
253 return parent::cast(a_class); 253 return parent::cast(a_class);
254 } 254 }
255 virtual cid id_cls() const {return id_clas 255 virtual cid id_cls() const {return id_class();}
256 virtual const std::string& name() const {r 256 virtual const std::string& name() const {return m_leaf.name();}
257 public: 257 public:
258 virtual bool fetch_entry() const {return _ 258 virtual bool fetch_entry() const {return _fetch_entry();}
259 public: 259 public:
260 column_vector_string_ref(ifile& a_file,bra 260 column_vector_string_ref(ifile& a_file,branch& a_branch,leaf_string& a_leaf,int64& a_index,
261 std::vector<std:: 261 std::vector<std::string>& a_ref,char a_sep)
262 :parent(a_file,a_branch,a_leaf,a_index,m_v 262 :parent(a_file,a_branch,a_leaf,a_index,m_value)
263 ,m_ref(a_ref) 263 ,m_ref(a_ref)
264 ,m_sep(a_sep) 264 ,m_sep(a_sep)
265 {} 265 {}
266 virtual ~column_vector_string_ref(){} 266 virtual ~column_vector_string_ref(){}
267 protected: 267 protected:
268 column_vector_string_ref(const column_vect 268 column_vector_string_ref(const column_vector_string_ref& a_from)
269 :read::icol(a_from) 269 :read::icol(a_from)
270 ,parent(a_from) 270 ,parent(a_from)
271 ,m_ref(a_from.m_ref) 271 ,m_ref(a_from.m_ref)
272 ,m_sep(a_from.m_sep) 272 ,m_sep(a_from.m_sep)
273 {} 273 {}
274 column_vector_string_ref& operator=(const 274 column_vector_string_ref& operator=(const column_vector_string_ref& a_from){
275 if(&a_from==this) return *this; 275 if(&a_from==this) return *this;
276 m_sep = a_from.m_sep; 276 m_sep = a_from.m_sep;
277 return *this; 277 return *this;
278 } 278 }
279 public: 279 public:
280 bool get_entry(std::vector<std::string>& a 280 bool get_entry(std::vector<std::string>& a_v) const {
281 if(!_fetch_entry()) {a_v.clear();return 281 if(!_fetch_entry()) {a_v.clear();return false;}
282 a_v = m_ref; 282 a_v = m_ref;
283 return true; 283 return true;
284 } 284 }
285 protected: 285 protected:
286 bool _fetch_entry() const { 286 bool _fetch_entry() const {
287 if(!parent::_fetch_entry()) return false 287 if(!parent::_fetch_entry()) return false;
288 get_lines(m_value,m_ref); 288 get_lines(m_value,m_ref);
289 return true; 289 return true;
290 } 290 }
291 protected: 291 protected:
292 std::vector<std::string>& m_ref; 292 std::vector<std::string>& m_ref;
293 char m_sep; 293 char m_sep;
294 std::string m_value; 294 std::string m_value;
295 }; 295 };
296 296
297 class column_vector_string : public column_v 297 class column_vector_string : public column_vector_string_ref {
298 typedef column_vector_string_ref parent; 298 typedef column_vector_string_ref parent;
299 public: 299 public:
300 static cid id_class() {return _cid_std_vec 300 static cid id_class() {return _cid_std_vector<std::string>();}
301 public: //icol 301 public: //icol
302 virtual void* cast(cid a_class) const { 302 virtual void* cast(cid a_class) const {
303 if(void* p = cmp_cast<column_vector_stri 303 if(void* p = cmp_cast<column_vector_string>(this,a_class)) return p;
304 return parent::cast(a_class); 304 return parent::cast(a_class);
305 } 305 }
306 virtual cid id_cls() const {return id_clas 306 virtual cid id_cls() const {return id_class();}
307 virtual const std::string& name() const {r 307 virtual const std::string& name() const {return m_leaf.name();}
308 public: 308 public:
309 column_vector_string(ifile& a_file,branch& 309 column_vector_string(ifile& a_file,branch& a_branch,leaf_string& a_leaf,int64& a_index,char a_sep)
310 :parent(a_file,a_branch,a_leaf,a_index,m_v 310 :parent(a_file,a_branch,a_leaf,a_index,m_value,a_sep)
311 {} 311 {}
312 virtual ~column_vector_string(){} 312 virtual ~column_vector_string(){}
313 protected: 313 protected:
314 column_vector_string(const column_vector_s 314 column_vector_string(const column_vector_string& a_from)
315 :read::icol(a_from) 315 :read::icol(a_from)
316 ,parent(a_from) 316 ,parent(a_from)
317 ,m_value(a_from.m_value) 317 ,m_value(a_from.m_value)
318 {} 318 {}
319 column_vector_string& operator=(const colu 319 column_vector_string& operator=(const column_vector_string& a_from){
320 if(&a_from==this) return *this; 320 if(&a_from==this) return *this;
321 m_value = a_from.m_value; 321 m_value = a_from.m_value;
322 return *this; 322 return *this;
323 } 323 }
324 public: 324 public:
325 const std::vector<std::string>& get_value( 325 const std::vector<std::string>& get_value() const {return m_value;}
326 protected: 326 protected:
327 std::vector<std::string> m_value; 327 std::vector<std::string> m_value;
328 }; 328 };
329 329
330 // to read row_wise columns with vector of b 330 // to read row_wise columns with vector of basic types :
331 template <class T> 331 template <class T>
332 class std_vector_column_ref : public virtual 332 class std_vector_column_ref : public virtual read::icolumn<T> {
333 typedef read::icolumn<T> parent; 333 typedef read::icolumn<T> parent;
334 public: 334 public:
335 static cid id_class() {return 200+_cid(T() 335 static cid id_class() {return 200+_cid(T())+10000;}
336 public: //icol 336 public: //icol
337 virtual void* cast(cid a_class) const { 337 virtual void* cast(cid a_class) const {
338 if(void* p = cmp_cast<std_vector_column_ 338 if(void* p = cmp_cast<std_vector_column_ref>(this,a_class)) return p;
339 return parent::cast(a_class); 339 return parent::cast(a_class);
340 } 340 }
341 virtual cid id_cls() const {return id_clas 341 virtual cid id_cls() const {return id_class();}
342 public: //icol 342 public: //icol
343 virtual const std::string& name() const {r 343 virtual const std::string& name() const {return m_leaf.name();}
344 public: //icolumn<T> 344 public: //icolumn<T>
345 virtual bool fetch_entry() const {return _ 345 virtual bool fetch_entry() const {return _fetch_entry();}
346 virtual bool get_entry(T& a_v) const { 346 virtual bool get_entry(T& a_v) const {
347 if(!_fetch_entry()) {a_v = T();return fa 347 if(!_fetch_entry()) {a_v = T();return false;}
348 if(m_ref.empty()) {a_v = T();return fals 348 if(m_ref.empty()) {a_v = T();return false;}
349 a_v = m_ref[0]; 349 a_v = m_ref[0];
350 return true; 350 return true;
351 } 351 }
352 public: 352 public:
353 std_vector_column_ref(ifile& a_file,branch 353 std_vector_column_ref(ifile& a_file,branch& a_branch,leaf<T>& a_leaf,int64& a_index,std::vector<T>& a_ref)
354 :m_file(a_file) 354 :m_file(a_file)
355 ,m_branch(a_branch) 355 ,m_branch(a_branch)
356 ,m_leaf(a_leaf) 356 ,m_leaf(a_leaf)
357 ,m_index(a_index) //WARNING : we keep the 357 ,m_index(a_index) //WARNING : we keep the ref !
358 ,m_ref(a_ref) 358 ,m_ref(a_ref)
359 {} 359 {}
360 virtual ~std_vector_column_ref(){} 360 virtual ~std_vector_column_ref(){}
361 protected: 361 protected:
362 std_vector_column_ref(const std_vector_col 362 std_vector_column_ref(const std_vector_column_ref& a_from)
363 :read::icol(a_from) 363 :read::icol(a_from)
364 ,parent(a_from) 364 ,parent(a_from)
365 ,m_file(a_from.m_file) 365 ,m_file(a_from.m_file)
366 ,m_branch(a_from.m_branch) 366 ,m_branch(a_from.m_branch)
367 ,m_leaf(a_from.m_leaf) 367 ,m_leaf(a_from.m_leaf)
368 ,m_index(a_from.m_index) 368 ,m_index(a_from.m_index)
369 ,m_ref(a_from.m_ref) 369 ,m_ref(a_from.m_ref)
370 {} 370 {}
371 std_vector_column_ref& operator=(const std 371 std_vector_column_ref& operator=(const std_vector_column_ref& a_from){
372 if(&a_from==this) return *this; 372 if(&a_from==this) return *this;
373 return *this; 373 return *this;
374 } 374 }
375 protected: 375 protected:
376 bool _fetch_entry() const { 376 bool _fetch_entry() const {
377 unsigned int n; 377 unsigned int n;
378 if(!m_branch.find_entry(m_file,uint32(m_ 378 if(!m_branch.find_entry(m_file,uint32(m_index),n)) {m_ref.clear();return false;}
379 m_leaf.value(m_ref); 379 m_leaf.value(m_ref);
380 return true; 380 return true;
381 } 381 }
382 protected: 382 protected:
383 ifile& m_file; 383 ifile& m_file;
384 branch& m_branch; 384 branch& m_branch;
385 leaf<T>& m_leaf; 385 leaf<T>& m_leaf;
386 int64& m_index; //WARNING : a ref. 386 int64& m_index; //WARNING : a ref.
387 std::vector<T>& m_ref; 387 std::vector<T>& m_ref;
388 }; 388 };
389 389
390 // to read column_wise columns with vector o 390 // to read column_wise columns with vector of basic types :
391 template <class RT,class T> 391 template <class RT,class T>
392 class column_element_ref : public virtual re 392 class column_element_ref : public virtual read::icolumn<T> {
393 typedef read::icolumn<T> parent; 393 typedef read::icolumn<T> parent;
394 public: 394 public:
395 static cid id_class() {return 300+_cid(T() 395 static cid id_class() {return 300+_cid(T())+10000;}
396 public: //icol 396 public: //icol
397 virtual void* cast(cid a_class) const { 397 virtual void* cast(cid a_class) const {
398 if(void* p = cmp_cast<column_element_ref 398 if(void* p = cmp_cast<column_element_ref>(this,a_class)) return p;
399 return parent::cast(a_class); 399 return parent::cast(a_class);
400 } 400 }
401 virtual cid id_cls() const {return id_clas 401 virtual cid id_cls() const {return id_class();}
402 public: //icol 402 public: //icol
403 virtual const std::string& name() const {r 403 virtual const std::string& name() const {return m_leaf.name();}
404 public: //icolumn<T> 404 public: //icolumn<T>
405 virtual bool fetch_entry() const {return _ 405 virtual bool fetch_entry() const {return _fetch_entry();}
406 virtual bool get_entry(T& a_v) const { 406 virtual bool get_entry(T& a_v) const {
407 if(!_fetch_entry()) {a_v = T();return fa 407 if(!_fetch_entry()) {a_v = T();return false;}
408 a_v = m_ref; 408 a_v = m_ref;
409 return true; 409 return true;
410 } 410 }
411 public: 411 public:
412 column_element_ref(ifile& a_file,branch_el 412 column_element_ref(ifile& a_file,branch_element& a_branch,leaf_element& a_leaf,int64& a_index,T& a_ref)
413 :m_file(a_file) 413 :m_file(a_file)
414 ,m_be(a_branch) 414 ,m_be(a_branch)
415 ,m_leaf(a_leaf) 415 ,m_leaf(a_leaf)
416 ,m_index(a_index) //WARNING : we keep the 416 ,m_index(a_index) //WARNING : we keep the ref !
417 ,m_ref(a_ref) 417 ,m_ref(a_ref)
418 {} 418 {}
419 virtual ~column_element_ref(){} 419 virtual ~column_element_ref(){}
420 protected: 420 protected:
421 column_element_ref(const column_element_re 421 column_element_ref(const column_element_ref& a_from)
422 :read::icol(a_from),parent(a_from) 422 :read::icol(a_from),parent(a_from)
423 ,m_file(a_from.m_file) 423 ,m_file(a_from.m_file)
424 ,m_be(a_from.m_be) 424 ,m_be(a_from.m_be)
425 ,m_leaf(a_from.m_leaf) 425 ,m_leaf(a_from.m_leaf)
426 ,m_index(a_from.m_index) 426 ,m_index(a_from.m_index)
427 ,m_ref(a_from.m_ref) 427 ,m_ref(a_from.m_ref)
428 {} 428 {}
429 column_element_ref& operator=(const column 429 column_element_ref& operator=(const column_element_ref& a_from){
430 if(&a_from==this) return *this; 430 if(&a_from==this) return *this;
431 return *this; 431 return *this;
432 } 432 }
433 protected: 433 protected:
434 bool _fetch_entry() const { 434 bool _fetch_entry() const {
435 unsigned int n; 435 unsigned int n;
436 if(!m_be.find_entry(m_file,uint32(m_inde 436 if(!m_be.find_entry(m_file,uint32(m_index),n)) {m_ref = T();return false;}
437 iro* obj = m_be.object(); //Not owner. 437 iro* obj = m_be.object(); //Not owner.
438 if(!obj) {m_ref = T();return false;} 438 if(!obj) {m_ref = T();return false;}
439 RT* v = id_cast<iro,RT>(*obj); 439 RT* v = id_cast<iro,RT>(*obj);
440 if(!v) {m_ref = T();return false;} 440 if(!v) {m_ref = T();return false;}
441 m_ref = *v; //it assumes a T::operator=( 441 m_ref = *v; //it assumes a T::operator=(RT)
442 return true; 442 return true;
443 } 443 }
444 protected: 444 protected:
445 ifile& m_file; 445 ifile& m_file;
446 branch_element& m_be; 446 branch_element& m_be;
447 leaf_element& m_leaf; 447 leaf_element& m_leaf;
448 int64& m_index; //WARNING : a ref. 448 int64& m_index; //WARNING : a ref.
449 T& m_ref; 449 T& m_ref;
450 }; 450 };
451 451
452 template <class RT,class T> 452 template <class RT,class T>
453 class column_element : public column_element 453 class column_element : public column_element_ref<RT,T> {
454 typedef column_element_ref<RT,T> parent; 454 typedef column_element_ref<RT,T> parent;
455 public: 455 public:
456 static cid id_class() {return 300+_cid(T() 456 static cid id_class() {return 300+_cid(T());}
457 public: //icol 457 public: //icol
458 virtual void* cast(cid a_class) const { 458 virtual void* cast(cid a_class) const {
459 if(void* p = cmp_cast<column_element>(th 459 if(void* p = cmp_cast<column_element>(this,a_class)) return p;
460 return parent::cast(a_class); 460 return parent::cast(a_class);
461 } 461 }
462 virtual cid id_cls() const {return id_clas 462 virtual cid id_cls() const {return id_class();}
463 public: 463 public:
464 column_element(ifile& a_file,branch_elemen 464 column_element(ifile& a_file,branch_element& a_branch,leaf_element& a_leaf,int64& a_index)
465 :parent(a_file,a_branch,a_leaf,a_index,m_v 465 :parent(a_file,a_branch,a_leaf,a_index,m_value)
466 ,m_value(T()) 466 ,m_value(T())
467 {} 467 {}
468 virtual ~column_element(){} 468 virtual ~column_element(){}
469 protected: 469 protected:
470 column_element(const column_element& a_fro 470 column_element(const column_element& a_from)
471 :read::icol(a_from) 471 :read::icol(a_from)
472 ,read::icolumn<T>(a_from) 472 ,read::icolumn<T>(a_from)
473 ,parent(a_from) 473 ,parent(a_from)
474 ,m_value(a_from.m_value) 474 ,m_value(a_from.m_value)
475 {} 475 {}
476 column_element& operator=(const column_ele 476 column_element& operator=(const column_element& a_from){
477 if(&a_from==this) return *this; 477 if(&a_from==this) return *this;
478 m_value = a_from.m_value; 478 m_value = a_from.m_value;
479 return *this; 479 return *this;
480 } 480 }
481 public: 481 public:
482 const T& get_value() const {return m_value 482 const T& get_value() const {return m_value;}
483 protected: 483 protected:
484 T m_value; 484 T m_value;
485 }; 485 };
486 486
487 public: 487 public:
488 ntuple(tree& a_tree):m_tree(a_tree),m_index( 488 ntuple(tree& a_tree):m_tree(a_tree),m_index(-1){
489 #ifdef TOOLS_MEM 489 #ifdef TOOLS_MEM
490 mem::increment(s_class().c_str()); 490 mem::increment(s_class().c_str());
491 #endif 491 #endif
492 } 492 }
493 virtual ~ntuple() { 493 virtual ~ntuple() {
494 safe_clear<read::icol>(m_cols); 494 safe_clear<read::icol>(m_cols);
495 #ifdef TOOLS_MEM 495 #ifdef TOOLS_MEM
496 mem::decrement(s_class().c_str()); 496 mem::decrement(s_class().c_str());
497 #endif 497 #endif
498 } 498 }
499 protected: 499 protected:
500 ntuple(const ntuple& a_from) 500 ntuple(const ntuple& a_from)
501 :parent(a_from),m_tree(a_from.m_tree){ 501 :parent(a_from),m_tree(a_from.m_tree){
502 #ifdef TOOLS_MEM 502 #ifdef TOOLS_MEM
503 mem::increment(s_class().c_str()); 503 mem::increment(s_class().c_str());
504 #endif 504 #endif
505 } 505 }
506 ntuple& operator=(const ntuple&){return *thi 506 ntuple& operator=(const ntuple&){return *this;}
507 public: 507 public:
508 bool initialize(std::ostream& a_out,const nt 508 bool initialize(std::ostream& a_out,const ntuple_binding& a_bd = ntuple_binding(),bool a_enforce_double = false) {
509 safe_clear<read::icol>(m_cols); 509 safe_clear<read::icol>(m_cols);
510 510
511 std::vector<base_leaf*> leaves; 511 std::vector<base_leaf*> leaves;
512 m_tree.find_leaves(leaves); 512 m_tree.find_leaves(leaves);
513 tools_vforcit(base_leaf*,leaves,it) { 513 tools_vforcit(base_leaf*,leaves,it) {
514 base_leaf* bl = (*it); 514 base_leaf* bl = (*it);
515 if(find_named<read::icol>(m_cols,bl->nam 515 if(find_named<read::icol>(m_cols,bl->name())) {
516 a_out << "tools::rroot::ntuple::initia 516 a_out << "tools::rroot::ntuple::initialize :"
517 << " column with name " << sout( 517 << " column with name " << sout(bl->name())
518 << " already exists." 518 << " already exists."
519 << std::endl; 519 << std::endl;
520 safe_clear<read::icol>(m_cols); 520 safe_clear<read::icol>(m_cols);
521 return false; 521 return false;
522 } 522 }
523 branch* _branch = m_tree.find_leaf_branc 523 branch* _branch = m_tree.find_leaf_branch(*bl);
524 if(!_branch) { 524 if(!_branch) {
525 a_out << "tools::rroot::ntuple::initia 525 a_out << "tools::rroot::ntuple::initialize :"
526 << " can't find branch of leaf " 526 << " can't find branch of leaf " << sout(bl->name()) << "."
527 << std::endl; 527 << std::endl;
528 safe_clear<read::icol>(m_cols); 528 safe_clear<read::icol>(m_cols);
529 return false; 529 return false;
530 } 530 }
531 531
532 //a_out << "tools::rroot::ntuple::initia 532 //a_out << "tools::rroot::ntuple::initialize :"
533 // << " branch " << _branch->name() 533 // << " branch " << _branch->name()
534 // << ", entries " << _branch->entr 534 // << ", entries " << _branch->entry_number() << "."
535 // << std::endl; 535 // << std::endl;
536 536
537 #define TOOLS_RROOT_NTUPLE_CREATE_COL(a__type) 537 #define TOOLS_RROOT_NTUPLE_CREATE_COL(a__type) \
538 if(leaf<a__type>* lf_##a__type = safe_ca 538 if(leaf<a__type>* lf_##a__type = safe_cast<base_leaf, leaf<a__type> >(*bl) ){\
539 cid user_cid;void* user_obj;\ 539 cid user_cid;void* user_obj;\
540 a_bd.find_user_obj(bl->name(),user_cid 540 a_bd.find_user_obj(bl->name(),user_cid,user_obj);\
541 typedef leaf<a__type> leaf_t;\ 541 typedef leaf<a__type> leaf_t;\
542 if(!user_obj) {\ 542 if(!user_obj) {\
543 if(a_enforce_double) {\ 543 if(a_enforce_double) {\
544 column<double,leaf_t>* col = new c 544 column<double,leaf_t>* col = new column<double,leaf_t>(m_tree.file(),*_branch,*lf_##a__type,m_index);\
545 m_cols.push_back(col);\ 545 m_cols.push_back(col);\
546 } else {\ 546 } else {\
547 column<a__type,leaf_t>* col = new 547 column<a__type,leaf_t>* col = new column<a__type,leaf_t>(m_tree.file(),*_branch,*lf_##a__type,m_index);\
548 m_cols.push_back(col);\ 548 m_cols.push_back(col);\
549 }\ 549 }\
550 } else {\ 550 } else {\
551 const base_leaf* lfc = bl->leaf_coun 551 const base_leaf* lfc = bl->leaf_count();\
552 if(lfc) {\ 552 if(lfc) {\
553 /*::printf("debug : ntuple : creat 553 /*::printf("debug : ntuple : create col leaf count : %s\n",bl->name().c_str());*/\
554 if(user_cid!=_cid_std_vector<a__ty 554 if(user_cid!=_cid_std_vector<a__type>()) {\
555 a_out << "tools::rroot::ntuple:: 555 a_out << "tools::rroot::ntuple::initialize :"\
556 << " for leaf with name " 556 << " for leaf with name " << sout(bl->name())\
557 << ", user variable type i 557 << ", user variable type is not a std::vector of " << #a__type << "."\
558 << std::endl;\ 558 << std::endl;\
559 safe_clear<read::icol>(m_cols);\ 559 safe_clear<read::icol>(m_cols);\
560 return false;\ 560 return false;\
561 }\ 561 }\
562 std::vector<a__type>* user_var = ( 562 std::vector<a__type>* user_var = (std::vector<a__type>*)user_obj;\
563 std_vector_column_ref<a__type>* co 563 std_vector_column_ref<a__type>* col = new std_vector_column_ref<a__type>\
564 (m_tree.file(),*_branch,*lf_##a__type, 564 (m_tree.file(),*_branch,*lf_##a__type,m_index,*user_var);\
565 m_cols.push_back(col);\ 565 m_cols.push_back(col);\
566 } else {\ 566 } else {\
567 /*::printf("debug : ntuple : creat 567 /*::printf("debug : ntuple : create col : %s\n",bl->name().c_str());*/\
568 if(user_cid!=_cid(a__type())) {\ 568 if(user_cid!=_cid(a__type())) {\
569 a_out << "tools::rroot::ntuple:: 569 a_out << "tools::rroot::ntuple::initialize :"\
570 << " for leaf with name " 570 << " for leaf with name " << sout(bl->name())\
571 << ", user variable type i 571 << ", user variable type is not a " << #a__type << "."\
572 << std::endl;\ 572 << std::endl;\
573 safe_clear<read::icol>(m_cols);\ 573 safe_clear<read::icol>(m_cols);\
574 return false;\ 574 return false;\
575 }\ 575 }\
576 a__type* user_var = (a__type*)user 576 a__type* user_var = (a__type*)user_obj;\
577 column_ref<a__type,leaf_t>* col =\ 577 column_ref<a__type,leaf_t>* col =\
578 new column_ref<a__type,leaf_t>(m 578 new column_ref<a__type,leaf_t>(m_tree.file(),*_branch,*lf_##a__type,m_index,*user_var);\
579 m_cols.push_back(col);\ 579 m_cols.push_back(col);\
580 }\ 580 }\
581 }\ 581 }\
582 } 582 }
583 583
584 //below types are in sync with wroot/ntu 584 //below types are in sync with wroot/ntuple.
585 585
586 TOOLS_RROOT_NTUPLE_CREATE_COL(char) 586 TOOLS_RROOT_NTUPLE_CREATE_COL(char)
587 else TOOLS_RROOT_NTUPLE_CREATE_COL(short 587 else TOOLS_RROOT_NTUPLE_CREATE_COL(short)
588 else TOOLS_RROOT_NTUPLE_CREATE_COL(int) 588 else TOOLS_RROOT_NTUPLE_CREATE_COL(int)
589 else TOOLS_RROOT_NTUPLE_CREATE_COL(float 589 else TOOLS_RROOT_NTUPLE_CREATE_COL(float)
590 else TOOLS_RROOT_NTUPLE_CREATE_COL(doubl 590 else TOOLS_RROOT_NTUPLE_CREATE_COL(double)
591 591
592 else if(leaf_string* ls = safe_cast<base 592 else if(leaf_string* ls = safe_cast<base_leaf, leaf_string >(*bl) ){
593 char sep = '\n'; 593 char sep = '\n';
594 cid user_cid;void* user_obj; 594 cid user_cid;void* user_obj;
595 if(!a_bd.find_user_obj(bl->name(),user 595 if(!a_bd.find_user_obj(bl->name(),user_cid,user_obj)) {
596 column_vector_string* col = new colu 596 column_vector_string* col = new column_vector_string(m_tree.file(),*_branch,*ls,m_index,sep);
597 m_cols.push_back(col); 597 m_cols.push_back(col);
598 } else if(user_cid==_cid_std_vector<std::str 598 } else if(user_cid==_cid_std_vector<std::string>()) {
599 std::vector<std::string>* user_var = 599 std::vector<std::string>* user_var = (std::vector<std::string>*)user_obj;
600 if(user_var) { 600 if(user_var) {
601 column_vector_string_ref* col = ne 601 column_vector_string_ref* col = new column_vector_string_ref(m_tree.file(),*_branch,*ls,m_index,*user_var,sep);
602 m_cols.push_back(col); 602 m_cols.push_back(col);
603 } else { 603 } else {
604 column_vector_string* col = new column_v 604 column_vector_string* col = new column_vector_string(m_tree.file(),*_branch,*ls,m_index,sep);
605 m_cols.push_back(col); 605 m_cols.push_back(col);
606 } 606 }
607 } else if(user_cid==_cid(std::string() 607 } else if(user_cid==_cid(std::string())) {
608 std::string* user_var = (std::string 608 std::string* user_var = (std::string*)user_obj;
609 if(user_var) { 609 if(user_var) {
610 column_string_ref* col = new colum 610 column_string_ref* col = new column_string_ref(m_tree.file(),*_branch,*ls,m_index,*user_var);
611 m_cols.push_back(col); 611 m_cols.push_back(col);
612 } else { 612 } else {
613 column_string* col = new column_string(m 613 column_string* col = new column_string(m_tree.file(),*_branch,*ls,m_index);
614 m_cols.push_back(col); 614 m_cols.push_back(col);
615 } 615 }
616 } else { 616 } else {
617 a_out << "tools::rroot::ntuple::init 617 a_out << "tools::rroot::ntuple::initialize :"
618 << " for leaf with name " << s 618 << " for leaf with name " << sout(ls->name())
619 << ", user variable type is no 619 << ", user variable type is not a std::string or a std::vector<std::string>."
620 << ". It's class id is " << us 620 << ". It's class id is " << user_cid << "."
621 << std::endl; 621 << std::endl;
622 safe_clear<read::icol>(m_cols); 622 safe_clear<read::icol>(m_cols);
623 return false; 623 return false;
624 } 624 }
625 625
626 } else if(leaf_element* le = safe_cast<b 626 } else if(leaf_element* le = safe_cast<base_leaf,leaf_element>(*bl) ){
627 627
628 branch_element* be = safe_cast<branch, 628 branch_element* be = safe_cast<branch,branch_element>(*_branch);
629 if(!be) { 629 if(!be) {
630 a_out << "tools::rroot::ntuple::init 630 a_out << "tools::rroot::ntuple::initialize : branch is not a branch_element." << std::endl;
631 safe_clear<read::icol>(m_cols); 631 safe_clear<read::icol>(m_cols);
632 return false; 632 return false;
633 } 633 }
634 634
635 #define TOOLS_RROOT_NTUPLE_CREATE_VEC_COL(a__n 635 #define TOOLS_RROOT_NTUPLE_CREATE_VEC_COL(a__name,a__type) \
636 if(be->class_name()==a__name) {\ 636 if(be->class_name()==a__name) {\
637 /*::printf("debug : ntuple : create 637 /*::printf("debug : ntuple : create vec col : %s\n",bl->name().c_str());*/\
638 typedef a__type el_t;\ 638 typedef a__type el_t;\
639 std::vector<el_t>* user_var = a_bd.f 639 std::vector<el_t>* user_var = a_bd.find_vector_variable<el_t>(bl->name());\
640 if(user_var) {\ 640 if(user_var) {\
641 typedef column_element_ref< stl_ve 641 typedef column_element_ref< stl_vector<el_t> , std::vector<el_t> > ce_t;\
642 ce_t* col = new ce_t(m_tree.file() 642 ce_t* col = new ce_t(m_tree.file(),*be,*le,m_index,*user_var);\
643 m_cols.push_back(col);\ 643 m_cols.push_back(col);\
644 } else {\ 644 } else {\
645 typedef column_element< stl_vector 645 typedef column_element< stl_vector<el_t> , std::vector<el_t> > ce_t;\
646 ce_t* col = new ce_t(m_tree.file() 646 ce_t* col = new ce_t(m_tree.file(),*be,*le,m_index);\
647 m_cols.push_back(col);\ 647 m_cols.push_back(col);\
648 }\ 648 }\
649 } 649 }
650 650
651 TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 651 TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<char>",char)
652 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 652 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<short>",short)
653 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 653 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<unsigned short>",unsigned short)
654 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 654 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<unsigned int>",unsigned int)
655 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 655 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<int>",int)
656 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 656 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<float>",float)
657 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 657 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<double>",double)
658 658
659 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 659 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<string>",std::string)
660 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 660 //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<unsigned long>",uint64) //beurk
661 661
662 // WARNING : take care of the space in 662 // WARNING : take care of the space in "> >".
663 /* VisualC++ : the below does not compile. 663 /* VisualC++ : the below does not compile.
664 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 664 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<unsigned short> >",std::vector<unsigned short>)
665 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 665 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<short> >",std::vector<short>)
666 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 666 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<unsigned int> >",std::vector<unsigned int>)
667 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 667 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<int> >",std::vector<short>)
668 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 668 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<float> >",std::vector<float>)
669 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 669 else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<double> >",std::vector<double>)
670 */ 670 */
671 671
672 else { 672 else {
673 a_out << "tools::rroot::ntuple::init 673 a_out << "tools::rroot::ntuple::initialize :"
674 << " WARNING : leaf element" 674 << " WARNING : leaf element"
675 << " with name " << sout(bl->n 675 << " with name " << sout(bl->name())
676 << ",title " << sout(bl->title 676 << ",title " << sout(bl->title())
677 << " br_elem class name " << b 677 << " br_elem class name " << be->class_name() << "."
678 << " entries " << be->entry_nu 678 << " entries " << be->entry_number() << "."
679 << std::endl; 679 << std::endl;
680 } 680 }
681 681
682 } else { 682 } else {
683 a_out << "tools::rroot::ntuple::initia 683 a_out << "tools::rroot::ntuple::initialize :"
684 << " WARNING : column type not y 684 << " WARNING : column type not yet handled for leaf"
685 << " with name " << sout(bl->nam 685 << " with name " << sout(bl->name())
686 << " and title " << sout(bl->tit 686 << " and title " << sout(bl->title()) << "."
687 << " s_cls() is " << sout(bl->s_ 687 << " s_cls() is " << sout(bl->s_cls()) << "."
688 << " Not fatal." 688 << " Not fatal."
689 << std::endl; 689 << std::endl;
690 } 690 }
691 691
692 } 692 }
693 693
694 #undef TOOLS_RROOT_NTUPLE_CREATE_VEC_COL 694 #undef TOOLS_RROOT_NTUPLE_CREATE_VEC_COL
695 #undef TOOLS_RROOT_NTUPLE_CREATE_COL 695 #undef TOOLS_RROOT_NTUPLE_CREATE_COL
696 696
697 size_t num = m_cols.size(); 697 size_t num = m_cols.size();
698 if(!num) { 698 if(!num) {
699 a_out << "tools::rroot::ntuple::initiali 699 a_out << "tools::rroot::ntuple::initialize :"
700 << " zero columns." 700 << " zero columns."
701 << std::endl; 701 << std::endl;
702 return false; 702 return false;
703 } 703 }
704 704
705 {tools_vforcit(column_binding,a_bd.columns( 705 {tools_vforcit(column_binding,a_bd.columns(),it) {
706 if(!find_named<read::icol>(m_cols,(*it). 706 if(!find_named<read::icol>(m_cols,(*it).name())) {
707 a_out << "tools::rroot::ntuple::initia 707 a_out << "tools::rroot::ntuple::initialize :"
708 << " warning : for column bindin 708 << " warning : for column binding with name " << sout((*it).name()) << ", no ntuple column found."
709 << std::endl; 709 << std::endl;
710 } 710 }
711 }} 711 }}
712 712
713 //a_out << "tools::rroot::ntuple::initiali 713 //a_out << "tools::rroot::ntuple::initialize :"
714 // << " number of columns " << num << 714 // << " number of columns " << num << "."
715 // << std::endl; 715 // << std::endl;
716 716
717 return true; 717 return true;
718 } 718 }
719 719
720 bool get_row() const { 720 bool get_row() const {
721 bool status = true; 721 bool status = true;
722 tools_vforcit(read::icol*,m_cols,it) { 722 tools_vforcit(read::icol*,m_cols,it) {
723 if(!(*it)->fetch_entry()) { 723 if(!(*it)->fetch_entry()) {
724 m_tree.out() << "tools::rroot::ntuple: 724 m_tree.out() << "tools::rroot::ntuple::get_row : fetch_entry() failed for leaf " << (*it)->name() << std::endl;
725 status = false; 725 status = false;
726 } 726 }
727 } 727 }
728 return status; 728 return status;
729 } 729 }
730 protected: 730 protected:
731 tree& m_tree; 731 tree& m_tree;
732 std::vector<read::icol*> m_cols; 732 std::vector<read::icol*> m_cols;
733 int64 m_index; 733 int64 m_index;
734 }; 734 };
735 735
736 // for gopaw : 736 // for gopaw :
737 737
738 class fac_tree_holder { 738 class fac_tree_holder {
739 public: 739 public:
740 fac_tree_holder(ifac* a_fac,tree* a_tree):m_ 740 fac_tree_holder(ifac* a_fac,tree* a_tree):m_fac(a_fac),m_tree(a_tree){} //own a_fac,a_tree.
741 virtual ~fac_tree_holder() {delete m_tree;de 741 virtual ~fac_tree_holder() {delete m_tree;delete m_fac;}
742 protected: 742 protected:
743 fac_tree_holder(const fac_tree_holder&){} 743 fac_tree_holder(const fac_tree_holder&){}
744 fac_tree_holder& operator=(const fac_tree_ho 744 fac_tree_holder& operator=(const fac_tree_holder&){return *this;}
745 protected: 745 protected:
746 ifac* m_fac; 746 ifac* m_fac;
747 tree* m_tree; 747 tree* m_tree;
748 }; 748 };
749 749
750 class fac_tree_ntuple : public fac_tree_holder 750 class fac_tree_ntuple : public fac_tree_holder, public ntuple { //fac_tree_holder must be first.
751 typedef ntuple parent; 751 typedef ntuple parent;
752 public: 752 public:
753 static const std::string& s_class() { 753 static const std::string& s_class() {
754 static const std::string s_v("tools::rroot 754 static const std::string s_v("tools::rroot::fac_tree_ntuple");
755 return s_v; 755 return s_v;
756 } 756 }
757 virtual const std::string& s_cls() const {re 757 virtual const std::string& s_cls() const {return s_class();}
758 public: 758 public:
759 fac_tree_ntuple(ifac* a_fac,tree* a_tree) // 759 fac_tree_ntuple(ifac* a_fac,tree* a_tree) //own these.
760 :fac_tree_holder(a_fac,a_tree) 760 :fac_tree_holder(a_fac,a_tree)
761 ,parent(*a_tree) //deleted first. 761 ,parent(*a_tree) //deleted first.
762 {} 762 {}
763 virtual ~fac_tree_ntuple() {} 763 virtual ~fac_tree_ntuple() {}
764 protected: 764 protected:
765 fac_tree_ntuple(const fac_tree_ntuple& a_fro 765 fac_tree_ntuple(const fac_tree_ntuple& a_from):read::intuple(a_from),fac_tree_holder(a_from),parent(a_from){}
766 fac_tree_ntuple& operator=(const fac_tree_nt 766 fac_tree_ntuple& operator=(const fac_tree_ntuple&){return *this;}
767 }; 767 };
768 768
769 }} 769 }}
770 770
771 #endif 771 #endif