| Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights reserved.
2 // See the file tools.license for terms.
3
4 #ifndef tools_wroot_leaf
5 #define tools_wroot_leaf
6
7 #include "base_leaf"
8
9 #include "../cids"
10 #include "../vdata"
11
12 namespace tools {
13 namespace wroot {
14
15 inline const std::string& leaf_store_class(char) {
16 static const std::string s_v("TLeafB");
17 return s_v;
18 }
19 inline const std::string& leaf_store_class(short) {
20 static const std::string s_v("TLeafS");
21 return s_v;
22 }
23 inline const std::string& leaf_store_class(int) {
24 static const std::string s_v("TLeafI");
25 return s_v;
26 }
27 inline const std::string& leaf_store_class(float) {
28 static const std::string s_v("TLeafF");
29 return s_v;
30 }
31 inline const std::string& leaf_store_class(double) {
32 static const std::string s_v("TLeafD");
33 return s_v;
34 }
35 inline const std::string& leaf_string_store_class() {
36 static const std::string s_v("TLeafC");
37 return s_v;
38 }
39 inline const std::string& leaf_element_store_class() {
40 static const std::string s_v("TLeafElement");
41 return s_v;
42 }
43 inline const std::string& leaf_object_store_class() {
44 static const std::string s_v("TLeafObject");
45 return s_v;
46 }
47
48 template <class T>
49 class leaf_ref : public base_leaf {
50 typedef base_leaf parent;
51 public:
52 static cid id_class() {return base_leaf_cid()+_cid(T())+10000;} //10000 same as in ntuple::column_ref.
53 virtual void* cast(cid a_class) const {
54 if(void* p = cmp_cast<leaf_ref>(this,a_class)) {return p;}
55 return parent::cast(a_class);
56 }
57 virtual cid id_cls() const {return id_class();}
58 public: //ibo
59 virtual const std::string& store_cls() const {return leaf_store_class(T());}
60 virtual bool stream(buffer& a_buffer) const {
61 unsigned int c;
62 if(!a_buffer.write_version(1,c)) return false;
63 if(!parent::stream(a_buffer)) return false;
64 if(!a_buffer.write(m_min)) return false;
65 if(!a_buffer.write(m_max)) return false;
66 if(!a_buffer.set_byte_count(c)) return false;
67 return true;
68 }
69 public: //base_leaf
70 virtual bool fill_buffer(buffer& a_buffer) const {
71 if(m_is_range) {
72 if(m_ref>=m_max) {
73 leaf_ref& self = const_cast<leaf_ref&>(*this);
74 self.m_max = m_ref;
75 }
76 }
77 return a_buffer.write<T>(m_ref);
78 }
79 public:
80 leaf_ref(std::ostream& a_out,const std::string& a_name,const T& a_ref)
81 :parent(a_out,a_name,a_name)
82 ,m_min(T()),m_max(T())
83 ,m_ref(a_ref)
84 {
85 m_length = 1;
86 m_length_type = sizeof(T);
87 }
88 virtual ~leaf_ref(){}
89 protected:
90 leaf_ref(const leaf_ref& a_from):ibo(a_from),parent(a_from),m_ref(a_from.m_ref){}
91 leaf_ref& operator=(const leaf_ref&){return *this;}
92 public:
93 T get_max() const {return m_max;}
94 void set_max(const T& a_value) {m_max = a_value;}
95 public:
96 const T& variable() const {return m_ref;}
97 T& variable() {return const_cast<T&>(m_ref);}
98 protected:
99 T m_min; //Minimum value if leaf range is specified
100 T m_max; //Maximum value if leaf range is specified
101 const T& m_ref;
102 };
103
104 template <class T>
105 class leaf : public leaf_ref<T> {
106 typedef leaf_ref<T> parent;
107 public:
108 static cid id_class() {return base_leaf_cid()+_cid(T());}
109 virtual void* cast(cid a_class) const {
110 if(void* p = cmp_cast<leaf>(this,a_class)) {return p;}
111 return parent::cast(a_class);
112 }
113 virtual cid id_cls() const {return id_class();}
114 public:
115 leaf(std::ostream& a_out,const std::string& a_name)
116 :parent(a_out,a_name,m_value)
117 ,m_value(T())
118 {}
119 virtual ~leaf(){}
120 protected:
121 leaf(const leaf& a_from):ibo(a_from),parent(a_from){}
122 leaf& operator=(const leaf&){return *this;}
123 public:
124 void fill(const T& a_value) {m_value = a_value;}
125 protected:
126 T m_value;
127 };
128
129 class leaf_string_ref : public base_leaf {
130 typedef base_leaf parent;
131 public:
132 static cid id_class() {return leaf_string_cid()+10000;}
133 virtual void* cast(cid a_class) const {
134 if(void* p = cmp_cast<leaf_string_ref>(this,a_class)) {return p;}
135 return parent::cast(a_class);
136 }
137 virtual cid id_cls() const {return id_class();}
138 public: //ibo
139 virtual const std::string& store_cls() const {return leaf_string_store_class();}
140 virtual bool stream(buffer& a_buffer) const {
141 unsigned int c;
142 if(!a_buffer.write_version(1,c)) return false;
143 if(!parent::stream(a_buffer)) return false;
144 if(!a_buffer.write(m_min)) return false;
145 if(!a_buffer.write(m_max)) return false;
146 if(!a_buffer.set_byte_count(c)) return false;
147 return true;
148 }
149 public: //base_leaf
150 virtual bool fill_buffer(buffer& a_buffer) const {
151 leaf_string_ref& self = const_cast<leaf_string_ref&>(*this);
152 size_t len = ::strlen(m_ref.c_str());
153 if(len >= (size_t)m_max) self.m_max = int(len)+1;
154 if(len >= m_length) self.m_length = uint32(len)+1;
155 if(len < 255) {
156 if(!a_buffer.write<unsigned char>((unsigned char)len)) return false;
157 } else {
158 if(!a_buffer.write<unsigned char>(255)) return false;
159 if(!a_buffer.write<uint32>(uint32(len))) return false;
160 }
161 if(len) if(!a_buffer.write_fast_array(m_ref.c_str(),uint32(len))) return false;
162 return true;
163 }
164 public:
165 leaf_string_ref(std::ostream& a_out,const std::string& a_name,const std::string& a_ref)
166 :parent(a_out,a_name,a_name)
167 ,m_min(0),m_max(0)
168 ,m_ref(a_ref)
169 {
170 m_length_type = 1;
171 }
172 virtual ~leaf_string_ref(){}
173 protected:
174 leaf_string_ref(const leaf_string_ref& a_from):ibo(a_from),parent(a_from),m_ref(a_from.m_ref){}
175 leaf_string_ref& operator=(const leaf_string_ref&){return *this;}
176 public:
177 int get_max() const {return m_max;}
178 void set_max(int a_value) {m_max = a_value;}
179 public:
180 const std::string& variable() const {return m_ref;}
181 std::string& variable() {return const_cast<std::string&>(m_ref);}
182 protected:
183 int m_min; //Minimum value if leaf range is specified
184 int m_max; //Maximum value if leaf range is specified
185 const std::string& m_ref;
186 };
187
188 class leaf_string : public leaf_string_ref {
189 typedef leaf_string_ref parent;
190 public:
191 static cid id_class() {return leaf_string_cid();}
192 virtual void* cast(cid a_class) const {
193 if(void* p = cmp_cast<leaf_string>(this,a_class)) {return p;}
194 return parent::cast(a_class);
195 }
196 virtual cid id_cls() const {return id_class();}
197 public:
198 leaf_string(std::ostream& a_out,const std::string& a_name)
199 :parent(a_out,a_name,m_value)
200 {}
201 virtual ~leaf_string(){}
202 protected:
203 leaf_string(const leaf_string& a_from):ibo(a_from),parent(a_from){}
204 leaf_string& operator=(const leaf_string&){return *this;}
205 public:
206 void fill(const std::string& a_value) {m_value = a_value;}
207 protected:
208 std::string m_value;
209 };
210
211 // to store vector columns of a row_wise ntuple :
212 template <class T>
213 class leaf_std_vector_ref : public base_leaf {
214 typedef base_leaf parent;
215 public:
216 static cid id_class() {return base_leaf_cid()+_cid(std::vector<T>())+10000;} //10000 same as in ntuple::column_ref.
217 virtual void* cast(cid a_class) const {
218 if(void* p = cmp_cast<leaf_std_vector_ref>(this,a_class)) {return p;}
219 return parent::cast(a_class);
220 }
221 virtual cid id_cls() const {return id_class();}
222 public: //ibo
223 virtual const std::string& store_cls() const {return leaf_store_class(T());}
224 virtual bool stream(buffer& a_buffer) const {
225 unsigned int c;
226 if(!a_buffer.write_version(1,c)) return false;
227 if(!parent::stream(a_buffer)) return false;
228 if(!a_buffer.write(m_min)) return false;
229 if(!a_buffer.write(m_max)) return false;
230 if(!a_buffer.set_byte_count(c)) return false;
231 return true;
232 }
233 public: //base_leaf
234 virtual bool fill_buffer(buffer& a_buffer) const {
235 if(!a_buffer.write_fast_array(vec_data(m_ref),uint32(m_ref.size()))) return false;
236 return true;
237 }
238 public:
239 leaf_std_vector_ref(std::ostream& a_out,const std::string& a_name,
240 base_leaf& a_leaf_count,const std::vector<T>& a_ref)
241 :parent(a_out,a_name,a_name)
242 ,m_min(T()),m_max(T())
243 ,m_ref(a_ref)
244 {
245 parent::m_leaf_count = &a_leaf_count;
246 a_leaf_count.set_is_range(true);
247 m_length = 1;
248 m_length_type = sizeof(T);
249 }
250 virtual ~leaf_std_vector_ref(){}
251 protected:
252 leaf_std_vector_ref(const leaf_std_vector_ref& a_from):ibo(a_from),parent(a_from),m_ref(a_from.m_ref){}
253 leaf_std_vector_ref& operator=(const leaf_std_vector_ref&){return *this;}
254 public:
255 T get_max() const {return m_max;}
256 void set_max(const T& a_value) {m_max = a_value;}
257 public:
258 const std::vector<T>& variable() const {return m_ref;}
259 std::vector<T>& variable() {return const_cast< std::vector<T>& >(m_ref);}
260 protected:
261 T m_min; //Minimum value if leaf range is specified
262 T m_max; //Maximum value if leaf range is specified
263 const std::vector<T>& m_ref;
264 };
265
266 class leaf_element : public base_leaf {
267 typedef base_leaf parent;
268 public:
269 static cid id_class() {return leaf_element_cid();}
270 virtual void* cast(cid a_class) const {
271 if(void* p = cmp_cast<leaf_element>(this,a_class)) {return p;}
272 return base_leaf::cast(a_class);
273 }
274 virtual cid id_cls() const {return id_class();}
275 public:
276 virtual const std::string& store_cls() const {return leaf_element_store_class();}
277 virtual bool stream(buffer& a_buffer) const {
278 unsigned int c;
279 if(!a_buffer.write_version(1,c)) return false;
280 if(!parent::stream(a_buffer)) return false;
281
282 if(!a_buffer.write(fID)) return false;
283 if(!a_buffer.write(fType)) return false;
284
285 if(!a_buffer.set_byte_count(c)) return false;
286 return true;
287 }
288 public: //base_leaf
289 virtual bool fill_buffer(buffer&) const {
290 m_out << "tools::wroot::leaf_element::fill_buffer : dummy." << std::endl;
291 return false;
292 }
293 public:
294 leaf_element(std::ostream& a_out,const std::string& a_name,int a_id,int a_type)
295 :parent(a_out,a_name,a_name)
296 ,fID(a_id)
297 ,fType(a_type)
298 {}
299 virtual ~leaf_element(){}
300 protected:
301 leaf_element(const leaf_element& a_from):ibo(a_from),parent(a_from){}
302 leaf_element& operator=(const leaf_element& a_from){
303 parent::operator=(a_from);
304 return *this;
305 }
306 protected:
307 int fID; //element serial number in fInfo
308 int fType; //leaf type
309 };
310
311 }}
312
313 #include "iobject"
314
315 namespace tools {
316 namespace wroot {
317
318 class leaf_object : public base_leaf {
319 typedef base_leaf parent;
320 public:
321 static cid id_class() {return leaf_object_cid();}
322 virtual void* cast(cid a_class) const {
323 if(void* p = cmp_cast<leaf_object>(this,a_class)) {return p;}
324 return base_leaf::cast(a_class);
325 }
326 virtual cid id_cls() const {return id_class();}
327 public:
328 virtual const std::string& store_cls() const {return leaf_object_store_class();}
329 virtual bool stream(buffer& a_buffer) const {
330 unsigned int c;
331 if(!a_buffer.write_version(4,c)) return false;
332 if(!parent::stream(a_buffer)) return false;
333 if(!a_buffer.write(fVirtual)) return false;
334 if(!a_buffer.set_byte_count(c)) return false;
335 return true;
336 }
337 public: //base_leaf
338 virtual bool fill_buffer(buffer& a_buffer) const {
339 if(fVirtual) {
340 const std::string& _class = m_obj.store_class_name();
341 if(_class.size()>255) return false;
342 unsigned char n = (unsigned char)_class.size();
343 if(!a_buffer.write(n)) return false;
344 if(!a_buffer.write_fast_array(_class.c_str(),n+1)) return false;
345 }
346 return m_obj.stream(a_buffer);
347 }
348 public:
349 leaf_object(std::ostream& a_out,const std::string& a_name,const iobject& a_obj)
350 :parent(a_out,a_name,a_obj.store_class_name()) //CERN-ROOT/TLeafObject::Streamer() wants store class name on m_title.
351 ,m_obj(a_obj)
352 ,fVirtual(true)
353 {}
354 virtual ~leaf_object(){}
355 protected:
356 leaf_object(const leaf_object& a_from):ibo(a_from),parent(a_from),m_obj(a_from.m_obj),fVirtual(true){}
357 leaf_object& operator=(const leaf_object& a_from){
358 parent::operator=(a_from);
359 return *this;
360 }
361 protected:
362 const iobject& m_obj;
363 bool fVirtual; // Support for Virtuality
364 };
365
366 }}
367
368 #endif