Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 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(cha 16 static const std::string s_v("TLeafB"); 17 return s_v; 18 } 19 inline const std::string& leaf_store_class(sho 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(flo 28 static const std::string s_v("TLeafF"); 29 return s_v; 30 } 31 inline const std::string& leaf_store_class(dou 32 static const std::string s_v("TLeafD"); 33 return s_v; 34 } 35 inline const std::string& leaf_string_store_cl 36 static const std::string s_v("TLeafC"); 37 return s_v; 38 } 39 inline const std::string& leaf_element_store_c 40 static const std::string s_v("TLeafElement") 41 return s_v; 42 } 43 inline const std::string& leaf_object_store_cl 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( 53 virtual void* cast(cid a_class) const { 54 if(void* p = cmp_cast<leaf_ref>(this,a_cla 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 60 virtual bool stream(buffer& a_buffer) const 61 unsigned int c; 62 if(!a_buffer.write_version(1,c)) return fa 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 fal 67 return true; 68 } 69 public: //base_leaf 70 virtual bool fill_buffer(buffer& a_buffer) c 71 if(m_is_range) { 72 if(m_ref>=m_max) { 73 leaf_ref& self = const_cast<leaf_ref&> 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::stri 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) 91 leaf_ref& operator=(const leaf_ref&){return 92 public: 93 T get_max() const {return m_max;} 94 void set_max(const T& a_value) {m_max = a_va 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 100 T m_max; //Maximum value if leaf range is 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( 109 virtual void* cast(cid a_class) const { 110 if(void* p = cmp_cast<leaf>(this,a_class)) 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& 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( 122 leaf& operator=(const leaf&){return *this;} 123 public: 124 void fill(const T& a_value) {m_value = a_val 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_ci 133 virtual void* cast(cid a_class) const { 134 if(void* p = cmp_cast<leaf_string_ref>(thi 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 140 virtual bool stream(buffer& a_buffer) const 141 unsigned int c; 142 if(!a_buffer.write_version(1,c)) return fa 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 fal 147 return true; 148 } 149 public: //base_leaf 150 virtual bool fill_buffer(buffer& a_buffer) c 151 leaf_string_ref& self = const_cast<leaf_st 152 size_t len = ::strlen(m_ref.c_str()); 153 if(len >= (size_t)m_max) self.m_max = int( 154 if(len >= m_length) self.m_length = uint32 155 if(len < 255) { 156 if(!a_buffer.write<unsigned char>((unsig 157 } else { 158 if(!a_buffer.write<unsigned char>(255)) 159 if(!a_buffer.write<uint32>(uint32(len))) 160 } 161 if(len) if(!a_buffer.write_fast_array(m_re 162 return true; 163 } 164 public: 165 leaf_string_ref(std::ostream& a_out,const st 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_fro 175 leaf_string_ref& operator=(const leaf_string 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 181 std::string& variable() {return const_cast<s 182 protected: 183 int m_min; //Minimum value if leaf range is 184 int m_max; //Maximum value if leaf range is 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_ci 192 virtual void* cast(cid a_class) const { 193 if(void* p = cmp_cast<leaf_string>(this,a_ 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::s 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 204 leaf_string& operator=(const leaf_string&){r 205 public: 206 void fill(const std::string& a_value) {m_val 207 protected: 208 std::string m_value; 209 }; 210 211 // to store vector columns of a row_wise ntupl 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( 217 virtual void* cast(cid a_class) const { 218 if(void* p = cmp_cast<leaf_std_vector_ref> 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 224 virtual bool stream(buffer& a_buffer) const 225 unsigned int c; 226 if(!a_buffer.write_version(1,c)) return fa 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 fal 231 return true; 232 } 233 public: //base_leaf 234 virtual bool fill_buffer(buffer& a_buffer) c 235 if(!a_buffer.write_fast_array(vec_data(m_r 236 return true; 237 } 238 public: 239 leaf_std_vector_ref(std::ostream& a_out,cons 240 base_leaf& a_leaf_count, 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_re 253 leaf_std_vector_ref& operator=(const leaf_st 254 public: 255 T get_max() const {return m_max;} 256 void set_max(const T& a_value) {m_max = a_va 257 public: 258 const std::vector<T>& variable() const {retu 259 std::vector<T>& variable() {return const_cas 260 protected: 261 T m_min; //Minimum value if leaf range is 262 T m_max; //Maximum value if leaf range is 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_c 270 virtual void* cast(cid a_class) const { 271 if(void* p = cmp_cast<leaf_element>(this,a 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 277 virtual bool stream(buffer& a_buffer) const 278 unsigned int c; 279 if(!a_buffer.write_version(1,c)) return fa 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 fal 286 return true; 287 } 288 public: //base_leaf 289 virtual bool fill_buffer(buffer&) const { 290 m_out << "tools::wroot::leaf_element::fill 291 return false; 292 } 293 public: 294 leaf_element(std::ostream& a_out,const std:: 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 302 leaf_element& operator=(const leaf_element& 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_ci 322 virtual void* cast(cid a_class) const { 323 if(void* p = cmp_cast<leaf_object>(this,a_ 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 329 virtual bool stream(buffer& a_buffer) const 330 unsigned int c; 331 if(!a_buffer.write_version(4,c)) return fa 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 fal 335 return true; 336 } 337 public: //base_leaf 338 virtual bool fill_buffer(buffer& a_buffer) c 339 if(fVirtual) { 340 const std::string& _class = m_obj.store_ 341 if(_class.size()>255) return false; 342 unsigned char n = (unsigned char)_class. 343 if(!a_buffer.write(n)) return false; 344 if(!a_buffer.write_fast_array(_class.c_s 345 } 346 return m_obj.stream(a_buffer); 347 } 348 public: 349 leaf_object(std::ostream& a_out,const std::s 350 :parent(a_out,a_name,a_obj.store_class_name( 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 357 leaf_object& operator=(const leaf_object& a_ 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