| Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 1
2 // See the file tools.license for terms.
3
4 // common columns code for ntuple and base_pnt
5
6 template <class T>
7 class column_ref : public virtual icol {
8 #ifdef TOOLS_MEM
9 static const std::string& s_class() {
10 static const std::string s_v("tools::wro
11 return s_v;
12 }
13 #endif
14 public:
15 static cid id_class() {
16 static const T s_v = T(); //do that for
17 return _cid(s_v)+10000;
18 }
19 virtual void* cast(cid a_class) const {
20 if(void* p = cmp_cast<column_ref>(this,a
21 else return 0;
22 }
23 virtual cid id_cls() const {return id_clas
24 public: //icol
25 virtual void add() {}
26 virtual void set_def() {}
27 virtual const std::string& name() const {r
28 virtual void set_basket_size(uint32 a_size
29 virtual branch& get_branch() const {return
30 virtual base_leaf* get_leaf() const {retur
31 public:
32 column_ref(branch& a_branch,const std::str
33 :m_branch(a_branch),m_leaf(0)
34 {
35 #ifdef TOOLS_MEM
36 mem::increment(s_class().c_str());
37 #endif
38 m_leaf = m_branch.create_leaf_ref<T>(a_n
39 }
40 virtual ~column_ref(){
41 #ifdef TOOLS_MEM
42 mem::decrement(s_class().c_str());
43 #endif
44 }
45 protected:
46 column_ref(const column_ref& a_from)
47 :icol(a_from)
48 ,m_branch(a_from.m_branch)
49 ,m_leaf(0)
50 {}
51 column_ref& operator=(const column_ref& a_
52 if(&a_from==this) return *this;
53 m_leaf = 0;
54 return *this;
55 }
56 public:
57 const T& variable() const {return m_leaf->
58 T& variable() {return m_leaf->variable();}
59 protected:
60 branch& m_branch;
61 leaf_ref<T>* m_leaf;
62 };
63
64 template <class T>
65 class column : public column_ref<T> {
66 typedef column_ref<T> parent;
67 #ifdef TOOLS_MEM
68 static const std::string& s_class() {
69 static const std::string s_v("tools::wro
70 return s_v;
71 }
72 #endif
73 public:
74 static cid id_class() {
75 static const T s_v = T(); //do that for
76 return _cid(s_v);
77 }
78 virtual void* cast(cid a_class) const {
79 if(void* p = cmp_cast<column>(this,a_cla
80 else return 0;
81 }
82 virtual cid id_cls() const {return id_clas
83 public: //icol
84 virtual void set_def() {m_value = m_def;}
85 public:
86 column(branch& a_branch,const std::string&
87 :parent(a_branch,a_name,m_value)
88 ,m_def(a_def),m_value(a_def)
89 {
90 #ifdef TOOLS_MEM
91 mem::increment(s_class().c_str());
92 #endif
93 }
94 virtual ~column(){
95 #ifdef TOOLS_MEM
96 mem::decrement(s_class().c_str());
97 #endif
98 }
99 protected:
100 column(const column& a_from)
101 :icol(a_from)
102 ,parent(a_from)
103 ,m_def(a_from.m_def)
104 ,m_value(a_from.m_value)
105 {}
106 column& operator=(const column& a_from){
107 if(&a_from==this) return *this;
108 parent::operator=(a_from);
109 m_def = a_from.m_def;
110 m_value = a_from.m_value;
111 return *this;
112 }
113 public:
114 column& operator=(const T& a_value){m_valu
115 bool fill(const T& a_value) {m_value = a_v
116 protected:
117 T m_def;
118 T m_value;
119 };
120
121 class column_string_ref : public virtual ico
122 #ifdef TOOLS_MEM
123 static const std::string& s_class() {
124 static const std::string s_v("tools::wro
125 return s_v;
126 }
127 #endif
128 public:
129 static cid id_class() {
130 static const std::string s_v;
131 return _cid(s_v)+10000;
132 }
133 virtual void* cast(cid a_class) const {
134 if(void* p = cmp_cast<column_string_ref>
135 else return 0;
136 }
137 virtual cid id_cls() const {return id_clas
138 public: //icol
139 virtual void add() {}
140 virtual void set_def() {}
141 virtual const std::string& name() const {r
142 virtual void set_basket_size(uint32 a_size
143 virtual branch& get_branch() const {return
144 virtual base_leaf* get_leaf() const {retur
145 public:
146 column_string_ref(branch& a_branch,const s
147 :m_branch(a_branch),m_leaf(0)
148 {
149 #ifdef TOOLS_MEM
150 mem::increment(s_class().c_str());
151 #endif
152 m_leaf = m_branch.create_leaf_string_ref
153 }
154 virtual ~column_string_ref(){
155 #ifdef TOOLS_MEM
156 mem::decrement(s_class().c_str());
157 #endif
158 }
159 protected:
160 column_string_ref(const column_string_ref&
161 :icol(a_from)
162 ,m_branch(a_from.m_branch)
163 ,m_leaf(0)
164 {}
165 column_string_ref& operator=(const column_
166 if(&a_from==this) return *this;
167 m_leaf = 0;
168 return *this;
169 }
170 public:
171 const std::string& variable() const {retur
172 std::string& variable() {return m_leaf->va
173 protected:
174 branch& m_branch;
175 leaf_string_ref* m_leaf;
176 };
177
178 class column_string : public column_string_r
179 typedef column_string_ref parent;
180 #ifdef TOOLS_MEM
181 static const std::string& s_class() {
182 static const std::string s_v("tools::wro
183 return s_v;
184 }
185 #endif
186 public:
187 static cid id_class() {
188 static const std::string s_v;
189 return _cid(s_v);
190 }
191 virtual void* cast(cid a_class) const {
192 if(void* p = cmp_cast<column_string>(thi
193 else return 0;
194 }
195 virtual cid id_cls() const {return id_clas
196 public: //icol
197 virtual void set_def() {m_value = m_def;}
198 public:
199 column_string(branch& a_branch,const std::
200 :parent(a_branch,a_name,m_value)
201 ,m_def(a_def),m_value(a_def)
202 {
203 #ifdef TOOLS_MEM
204 mem::increment(s_class().c_str());
205 #endif
206 }
207 virtual ~column_string(){
208 #ifdef TOOLS_MEM
209 mem::decrement(s_class().c_str());
210 #endif
211 }
212 protected:
213 column_string(const column_string& a_from)
214 :icol(a_from)
215 ,parent(a_from)
216 ,m_def(a_from.m_def)
217 ,m_value(a_from.m_value)
218 {}
219 column_string& operator=(const column_stri
220 if(&a_from==this) return *this;
221 parent::operator=(a_from);
222 m_def = a_from.m_def;
223 m_value = a_from.m_value;
224 return *this;
225 }
226 public:
227 column_string& operator=(const std::string
228 bool fill(const std::string& a_value) {m_v
229 protected:
230 std::string m_def;
231 std::string m_value;
232 };
233
234 class column_vector_string_ref : public colu
235 typedef column_string_ref parent;
236 #ifdef TOOLS_MEM
237 static const std::string& s_class() {
238 static const std::string s_v("tools::wro
239 return s_v;
240 }
241 #endif
242 public:
243 static cid id_class() {return _cid_std_vec
244 virtual void* cast(cid a_class) const {
245 if(void* p = cmp_cast<column_vector_stri
246 else return 0;
247 }
248 virtual cid id_cls() const {return id_clas
249 public: //icol
250 virtual void add() {
251 m_string.clear();
252 tools_vforcit(std::string,m_ref,it) {
253 if(it!=m_ref.begin()) m_string += m_se
254 m_string += *it;
255 }
256 parent::add();
257 }
258 public:
259 column_vector_string_ref(branch& a_branch,
260 :parent(a_branch,a_name,m_string)
261 ,m_ref(a_ref)
262 ,m_sep(a_sep)
263 {
264 #ifdef TOOLS_MEM
265 mem::increment(s_class().c_str());
266 #endif
267 }
268 virtual ~column_vector_string_ref(){
269 #ifdef TOOLS_MEM
270 mem::decrement(s_class().c_str());
271 #endif
272 }
273 protected:
274 column_vector_string_ref(const column_vect
275 :icol(a_from)
276 ,parent(a_from)
277 ,m_ref(a_from.m_ref)
278 ,m_sep(a_from.m_sep)
279 {}
280 column_vector_string_ref& operator=(const
281 if(&a_from==this) return *this;
282 m_sep = a_from.m_sep;
283 return *this;
284 }
285 public:
286 const std::vector<std::string>& variable()
287 std::vector<std::string>& variable() {retu
288 protected:
289 const std::vector<std::string>& m_ref;
290 char m_sep;
291 std::string m_string;
292 };
293
294 class column_vector_string : public column_v
295 typedef column_vector_string_ref parent;
296 #ifdef TOOLS_MEM
297 static const std::string& s_class() {
298 static const std::string s_v("tools::wro
299 return s_v;
300 }
301 #endif
302 public:
303 static cid id_class() {return _cid_std_vec
304 virtual void* cast(cid a_class) const {
305 if(void* p = cmp_cast<column_vector_stri
306 else return 0;
307 }
308 virtual cid id_cls() const {return id_clas
309 public: //icol
310 virtual void set_def() {m_value = m_def;}
311 public:
312 column_vector_string(branch& a_branch,cons
313 :parent(a_branch,a_name,m_value,a_sep)
314 ,m_def(a_def),m_value(a_def)
315 {
316 #ifdef TOOLS_MEM
317 mem::increment(s_class().c_str());
318 #endif
319 }
320 virtual ~column_vector_string(){
321 #ifdef TOOLS_MEM
322 mem::decrement(s_class().c_str());
323 #endif
324 }
325 protected:
326 column_vector_string(const column_vector_s
327 :icol(a_from)
328 ,parent(a_from)
329 ,m_def(a_from.m_def)
330 ,m_value(a_from.m_value)
331 {}
332 column_vector_string& operator=(const colu
333 if(&a_from==this) return *this;
334 parent::operator=(a_from);
335 m_def = a_from.m_def;
336 m_value = a_from.m_value;
337 return *this;
338 }
339 public:
340 column_vector_string& operator=(const std:
341 bool fill(const std::vector<std::string>&
342 protected:
343 std::vector<std::string> m_def;
344 std::vector<std::string> m_value;
345 };
346
347 template <class T>
348 class std_vector_column_ref : public virtual
349 #ifdef TOOLS_MEM
350 static const std::string& s_class() {
351 static const std::string s_v("tools::wro
352 return s_v;
353 }
354 #endif
355 public:
356 static cid id_class() {return _cid_std_vec
357 virtual void* cast(cid a_class) const {
358 if(void* p = cmp_cast<std_vector_column_
359 else return 0;
360 }
361 virtual cid id_cls() const {return id_clas
362 public: //icol
363 virtual void add() {
364 if(m_leaf_count) m_leaf_count->fill((int
365 }
366 virtual void set_def() {}
367 virtual const std::string& name() const {r
368 virtual void set_basket_size(uint32 a_size
369 virtual branch& get_branch() const {return
370 virtual base_leaf* get_leaf() const {retur
371 public:
372 std_vector_column_ref(branch& a_branch,con
373 :m_branch(a_branch)
374 ,m_ref(a_ref)
375 ,m_leaf(0)
376 ,m_leaf_count(0) //row_wise
377 {
378 #ifdef TOOLS_MEM
379 mem::increment(s_class().c_str());
380 #endif
381 if(a_branch.store_cls()==branch_element_
382 //::printf("debug : std_vector_column_
383 int id = -1; //same as in std_vector_
384 int type = 0;
385 m_leaf = m_branch.create_leaf_element(
386 } else { //row_wise.
387 //::printf("debug : std_vector_column_
388 std::string leaf_count_name = a_name+"
389 m_leaf_count = m_branch.create_leaf<in
390 m_leaf = m_branch.create_leaf_std_vect
391 m_leaf->set_title(a_name+"["+leaf_coun
392 }
393 }
394 virtual ~std_vector_column_ref(){
395 #ifdef TOOLS_MEM
396 mem::decrement(s_class().c_str());
397 #endif
398 }
399 protected:
400 std_vector_column_ref(const std_vector_col
401 :icol(a_from)
402 ,m_branch(a_from.m_branch)
403 ,m_ref(a_from.m_ref)
404 ,m_leaf(0)
405 ,m_leaf_count(0)
406 {}
407 std_vector_column_ref& operator=(const std
408 if(&a_from==this) return *this;
409 m_leaf = 0;
410 m_leaf_count = 0;
411 return *this;
412 }
413 public:
414 const std::vector<T>& variable() const {re
415 std::vector<T>& variable() {return const_c
416 protected:
417 branch& m_branch;
418 const std::vector<T>& m_ref;
419 base_leaf* m_leaf;
420 leaf<int>* m_leaf_count; //row_wise.
421 };
422
423 template <class T>
424 class std_vector_column : public std_vector_
425 typedef std_vector_column_ref<T> parent;
426 #ifdef TOOLS_MEM
427 static const std::string& s_class() {
428 static const std::string s_v("tools::wro
429 return s_v;
430 }
431 #endif
432 public:
433 static cid id_class() {return _cid_std_vec
434 virtual void* cast(cid a_class) const {
435 if(void* p = cmp_cast<std_vector_column>
436 else return 0;
437 }
438 virtual cid id_cls() const {return id_clas
439 public: //icol
440 virtual void set_def() {m_value = m_def;}
441 public:
442 std_vector_column(branch& a_branch,const s
443 :parent(a_branch,a_name,m_value)
444 ,m_def(a_def),m_value(a_def)
445 {
446 #ifdef TOOLS_MEM
447 mem::increment(s_class().c_str());
448 #endif
449 }
450 virtual ~std_vector_column(){
451 #ifdef TOOLS_MEM
452 mem::decrement(s_class().c_str());
453 #endif
454 }
455 protected:
456 std_vector_column(const std_vector_column&
457 :icol(a_from)
458 ,parent(a_from)
459 ,m_def(a_from.m_def)
460 ,m_value(a_from.m_value)
461 {}
462 std_vector_column& operator=(const std_vec
463 if(&a_from==this) return *this;
464 parent::operator=(a_from);
465 m_def = a_from.m_def;
466 m_value = a_from.m_value;
467 return *this;
468 }
469 public:
470 std_vector_column& operator=(const std::ve
471 bool fill(const std::vector<T>& a_value) {
472 protected:
473 std::vector<T> m_def;
474 std::vector<T> m_value;
475 };
476