DD4hep - The AIDA detector description toolkit for high energy physics experiments
DD4hep  Rev:Unversioneddirectory
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Primitives.h
Go to the documentation of this file.
1 //==========================================================================
2 // AIDA Detector description implementation for LCD
3 //--------------------------------------------------------------------------
4 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
5 // All rights reserved.
6 //
7 // For the licensing terms see $DD4hepINSTALL/LICENSE.
8 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
9 //
10 // Author : M.Frank
11 //
12 //==========================================================================
13 #ifndef DD4HEP_DD4HEP_PRIMITIVES_H
14 #define DD4HEP_DD4HEP_PRIMITIVES_H
15 
16 // C/C++ include files
17 #include <map>
18 #include <vector>
19 #include <string>
20 #include <limits>
21 
22 #include <typeinfo>
23 #include <algorithm>
24 #include <stdexcept>
25 
27 namespace DD4hep {
28 
30  namespace DDSegmentation {
31  class BitField64;
34  typedef long long int CellID;
35  typedef long long int VolumeID;
36  }
37 
39  inline unsigned int hash32(const char* key) {
40  unsigned int hash = 0;
41  const char* k = key;
42  for (; *k; k++) {
43  hash += *k;
44  hash += (hash << 10);
45  hash ^= (hash >> 6);
46  }
47  hash += (hash << 3);
48  hash ^= (hash >> 11); hash += (hash << 15);
49  return hash;
50  }
51  inline unsigned int hash32(const std::string& key) {
52  return hash32(key.c_str());
53  }
54 
56  long int makeTime(int year, int month, int day,
57  int hour=0, int minutes=0, int seconds=0);
58 
60  long int makeTime(const std::string& date, const char* fmt="%d-%m-%Y %H:%M:%S");
61 
63  class invalid_handle_exception : public std::runtime_error {
64  public:
66  invalid_handle_exception(const char* msg) : std::runtime_error(msg) {}
68  invalid_handle_exception(const std::string& msg) : std::runtime_error(msg) {}
70  invalid_handle_exception(const std::exception& e) : std::runtime_error(e.what()) {}
72  invalid_handle_exception(const invalid_handle_exception& e) : std::runtime_error(e.what()) {}
74  virtual ~invalid_handle_exception() = default;
75  };
76 
78  std::string typeName(const std::type_info& type);
80  void typeinfoCheck(const std::type_info& typ1, const std::type_info& typ2, const std::string& text = "");
82  void invalidHandleError(const std::type_info& type);
84  void invalidHandleAssignmentError(const std::type_info& from, const std::type_info& to);
85 
87  template <typename T> void invalidHandleError() {
88  invalidHandleError(typeid(T));
89  }
90 
92  void notImplemented(const std::string& msg);
93 
94 
96 
102  template<typename T> struct Primitive {
103  public:
105  typedef T value_t;
107  typedef std::vector<value_t> vector_t;
108 
110  typedef std::pair<short,value_t> short_pair_t;
112  typedef std::pair<unsigned short,value_t> ushort_pair_t;
114  typedef std::pair<int,value_t> int_pair_t;
116  typedef std::pair<unsigned int,value_t> uint_pair_t;
118  typedef std::pair<long,value_t> long_pair_t;
120  typedef std::pair<unsigned long,value_t> ulong_pair_t;
122  typedef std::pair<size_t,value_t> size_pair_t;
124  typedef std::pair<std::string,value_t> string_pair_t;
125 
127  typedef std::map<short,value_t> short_map_t;
129  typedef std::map<unsigned short,value_t> ushort_map_t;
131  typedef std::map<int,value_t> int_map_t;
133  typedef std::map<unsigned int,value_t> uint_map_t;
135  typedef std::map<long,value_t> long_map_t;
137  typedef std::map<unsigned long,value_t> ulong_map_t;
139  typedef std::map<size_t,value_t> size_map_t;
141  typedef std::map<std::string,value_t> string_map_t;
143  typedef std::numeric_limits<value_t> limits;
144 
146  static const char* default_format();
148  static const char* format() { return default_format(); }
150  static const std::type_info& type() { return typeid(value_t); }
152  static std::string type_name() { return typeName(type()); }
154  static std::string toString(T value);
155  };
156 
157 
159 
169  public:
170  typedef void (*destroy_t)(void*);
171  typedef void* (*cast_t)(const void*);
172 #ifdef __CINT__
173  const std::type_info* type;
174 #else
175  const std::type_info& type;
176 #endif
177  const void* abi_class;
180 
181  private:
183  ComponentCast(const std::type_info& t, destroy_t d, cast_t c);
185  virtual ~ComponentCast();
186 
187  public:
188  template <typename TYPE> static void _destroy(void* p) {
189  TYPE* q = (TYPE*)p;
190  if (q) delete q;
191  }
192  template <typename TYPE> static void* _cast(const void* p) {
193  TYPE* q = (TYPE*)p;
194  q = dynamic_cast<TYPE*>(q);
195  return (void*)q;
196  }
197  template <typename TYPE> static ComponentCast& instance() {
198  static ComponentCast c(typeid(TYPE),_destroy<TYPE>,_cast<TYPE>);
199  return c;
200  }
201 
203  void* apply_dynCast(const ComponentCast& to, const void* ptr) const;
205  void* apply_upCast(const ComponentCast& to, const void* ptr) const;
207  void* apply_downCast(const ComponentCast& to, const void* ptr) const;
208  };
209 
210 
211  // Put here global basic type definitions derived from primitive types of the DD4hep namespace
212 #ifdef __CINT__
215  typedef DDSegmentation::BitField64 BitField64;
216  typedef DDSegmentation::BitFieldValue BitFieldValue;
217 #else
220  using DDSegmentation::BitField64;
221  using DDSegmentation::BitFieldValue;
222 #endif
223 
225  template <typename T> inline void copyObject(void* target,const void* source) {
226  const T* s = (const T*)source;
227  ::new(target) T(*s);
228  }
230  template <typename T> inline void destructObject(T* p) {
231  p->~T();
232  }
234  template <typename T> inline void deletePtr(T*& p) {
235  if (0 != p)
236  delete p;
237  p = 0;
238  }
240  template <typename T> inline void deleteObject(T* p) {
241  if (0 != p)
242  delete p;
243  }
245  template <typename T> inline void destroyObject(T*& p) {
246  deletePtr(p);
247  }
249  template <typename T> class DestroyObject {
250  public:
251  void operator()(T& p) const {
252  destroyObject(p);
253  }
254  };
255 
257  template <typename T> class Select2nd {
258  public:
259  typedef T arg_t;
260  typedef typename T::second_type result_t;
262  const result_t& operator()(const arg_t &p) const { return p.second; }
263  };
265  template <typename T> Select2nd<typename T::value_type> select2nd(const T&)
267 
269  template <typename T> class Select1st {
270  public:
271  typedef T arg_t;
272  typedef typename T::first_type result_t;
274  const result_t& operator()(const arg_t &p) const { return p.first; }
275  };
277  template <typename T> Select1st<typename T::value_type> select1st(const T&)
279 
280 
282  template <typename M> class DestroyObjects {
283  public:
284  M& object;
285  DestroyObjects(M& m) : object(m) { }
286  void operator()(std::pair<typename M::key_type, typename M::mapped_type> p) const
288  void operator()() const {
289  if ( !object.empty() ) for_each(object.begin(),object.end(),(*this));
290  object.clear();
291  }
292  };
293  template <typename M> void destroyObjects(M& m)
294  { DestroyObjects<M> del(m); del(); }
295  template <typename M> DestroyObjects<M> destroy2nd(M& m)
296  { DestroyObjects<M> del(m); del(); }
297 
299  template <typename M> class DestroyFirst {
300  public:
301  M& object;
302  DestroyFirst(M& m) : object(m) { }
303  void operator()(std::pair<typename M::key_type, typename M::mapped_type> p) const
305  void operator()() const {
306  if ( !object.empty() ) for_each(object.begin(),object.end(),(*this));
307  object.clear();
308  }
309  };
310  template <typename M> void destroyFirst(M& m)
311  { DestroyFirst<M> del(m); del(); }
312  template <typename M> void destroy1st(M& m)
313  { DestroyFirst<M> del(m); del(); }
314 
316  template <typename T> inline void releasePtr(T& p) {
317  if (0 != p)
318  p->release();
319  p = 0;
320  }
321 
323  template <typename T> class ReleaseObject {
324  public:
325  void operator()(T& p) const {
326  releasePtr(p);
327  }
328  };
330  template <typename M> class ReleaseObjects {
331  public:
332  M& object;
333  ReleaseObjects(M& m) : object(m) { }
334  void operator()(std::pair<typename M::key_type, typename M::mapped_type> p) const
336  void operator()() const {
337  if ( !object.empty() ) for_each(object.begin(),object.end(),(*this));
338  object.clear();
339  }
340  };
343  }
344  template <typename M> void releaseObjects(M& m) {
345  ReleaseObjects<M> rel(m); rel();
346  }
347  template <typename M> void release2nd(M& m) {
348  ReleaseObjects<M> rel(m); rel();
349  }
350 
352  template <typename T> class ReferenceObject {
353  public:
354  typedef T arg_t;
355  T operator()(T p) const {
356  if ( p ) p->addRef();
357  return p;
358  }
359  };
361  template <typename M> class ReferenceObjects {
362  public:
363  typedef typename M::second_type result_t;
364  result_t operator()(const M& p) const {
365  return ReferenceObject<result_t>()(p.second);
366  }
367  };
368  template <typename M> ReferenceObject<M> referenceObject(M&) {
370  }
373  }
374 
376  template <typename R, typename T> struct ApplyMemFunc {
377  typedef R (T::*memfunc_t)();
380  void operator()(T* p) const { if (p) { (p->*func)(); } }
381  };
382 
384  template <typename R, typename T, typename A1> struct ApplyMemFunc1 {
385  typedef R (T::*memfunc_t)(A1 a1);
387  A1& arg1;
388  ApplyMemFunc1(memfunc_t f, A1& a1) : func(f), arg1(a1) {}
389  void operator()(T* p) const { if ( p ) { (p->*func)(arg1); } }
390  };
391 
393  template <typename R, typename T, typename A1, typename A2> struct ApplyMemFunc2 {
394  typedef R (T::*memfunc_t)(A1 a1, A2 a2);
396  A1& arg1;
397  A2& arg2;
398  ApplyMemFunc2(memfunc_t f, A1& a1, A2& a2) : func(f), arg1(a1), arg2(a2) {}
399  void operator()( T* p) const { if ( p ) { (p->*func)(arg1, arg2); } }
400  };
401 
403  template <typename R, typename T> struct ApplyMemFuncConst {
404  typedef R (T::*memfunc_t)() const;
407  void operator()(const T* p) const { if ( p ) { (p->*func)(); } }
408  };
409 
411  template <typename R, typename T, typename A1> struct ApplyMemFuncConst1 {
412  typedef R (T::*memfunc_t)(A1 a1) const;
414  A1& arg1;
415  ApplyMemFuncConst1(memfunc_t f, A1& a1) : func(f), arg1(a1) {}
416  void operator()(const T* p) const { if ( p ) { (p->*func)(arg1); } }
417  };
418 
420  template <typename R, typename T, typename A1, typename A2> struct ApplyMemFuncConst2 {
421  typedef R (T::*memfunc_t)(A1 a1, A2 a2) const;
423  A1& arg1;
424  A2& arg2;
425  ApplyMemFuncConst2(memfunc_t f, A1& a1, A2& a2) : func(f), arg1(a1), arg2(a2) {}
426  void operator()(const T* p) const { if ( p ) { (p->*func)(arg1, arg2); } }
427  };
428 
429  template <typename C, typename R, typename T>
430  void call_member_func(C& object, R (T::*pmf)())
431  { std::for_each(object.begin(),object.end(),ApplyMemFunc<R,T>(pmf)); }
432 
433  template <typename C, typename R, typename T>
434  void call_member_func(C& object, R (T::*pmf)() const)
435  { std::for_each(object.begin(),object.end(),ApplyMemFuncConst<R,T>(pmf)); }
436 
437  template <typename C, typename R, typename T, typename A1>
438  void call_member_func(C& object, R (T::*pmf)(A1 a1), A1 a1)
439  { std::for_each(object.begin(),object.end(),ApplyMemFunc1<R,T,A1>(pmf,a1)); }
440 
441  template <typename C, typename R, typename T, typename A1>
442  void call_member_func(C& object, R (T::*pmf)(A1 a1) const, A1 a1)
443  { std::for_each(object.begin(),object.end(),ApplyMemFuncConst1<R,T,A1>(pmf,a1)); }
444 
445 
446  template <typename C, typename R, typename T, typename A1, typename A2>
447  void call_member_func(C& object, R (T::*pmf)(A1 a1,A2 a2), A1 a1, A2 a2)
448  { std::for_each(object.begin(),object.end(),ApplyMemFunc2<R,T,A1,A2>(pmf,a1,a2)); }
449 
450  template <typename C, typename R, typename T, typename A1, typename A2>
451  void call_member_func(C& object, R (T::*pmf)(A1 a1,A2 a2) const, A1 a1, A2 a2)
452  { std::for_each(object.begin(),object.end(),ApplyMemFuncConst2<R,T,A1,A2>(pmf,a1,a2)); }
453 
454 
456  template <typename M, typename FCN> class Apply1rst {
457  public:
458  const FCN& func;
459  Apply1rst(const FCN& f) : func(f) { }
460  void operator()(std::pair<typename M::key_type const, typename M::mapped_type>& p) const
461  { (func)(p.first); }
462  void operator()(const std::pair<typename M::key_type const, typename M::mapped_type>& p) const
463  { (func)(p.first); }
464  };
465 
466  template <typename C, typename FCN> Apply1rst<C,FCN> apply__1rst_value(C&,const FCN& func)
467  { return Apply1rst<C,FCN>(func); }
468 
469  template <typename C, typename FCN> void apply1rst(C& object,const FCN& func)
470  { std::for_each(object.begin(),object.end(),apply__1rst_value(object,func)); }
471 
472  template <typename C, typename R, typename T>
473  void apply1rst(C& object, R (T::*pmf)())
474  { std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFunc<R,T>(pmf))); }
475 
476  template <typename C, typename R, typename T, typename A1>
477  void apply1rst(C object, R (T::*pmf)(A1 a1), A1 a1)
478  { std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFunc1<R,T,A1>(pmf,a1))); }
479 
480  template <typename C, typename R, typename T>
481  void apply1rst(C& object, R (T::*pmf)() const)
482  { std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFuncConst<R,T>(pmf))); }
483 
484  template <typename C, typename R, typename T, typename A1>
485  void apply1rst(C object, R (T::*pmf)(A1 a1) const, A1 a1)
486  { std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFuncConst1<R,T,A1>(pmf,a1))); }
487 
489  template <typename M, typename FCN> class Apply2nd {
490  public:
491  const FCN& func;
492  Apply2nd(const FCN& f) : func(f) { }
493  void operator()(std::pair<typename M::key_type const, typename M::mapped_type>& p) const
494  { (func)(p.second); }
495  void operator()(const std::pair<typename M::key_type const, typename M::mapped_type>& p) const
496  { (func)(p.second); }
497  };
498 
499  template <typename C, typename FCN> Apply2nd<C,FCN> apply__2nd_value(C&,const FCN& func)
500  { return Apply2nd<C,FCN>(func); }
501 
502  template <typename C, typename FCN> void apply2nd(C& object,const FCN& func)
503  { std::for_each(object.begin(),object.end(),apply__2nd_value(object,func)); }
504 
505  template <typename C, typename R, typename T>
506  void apply2nd(C& object, R (T::*pmf)())
507  { std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFunc<R,T>(pmf))); }
508 
509  template <typename C, typename R, typename T, typename A1>
510  void apply2nd(C object, R (T::*pmf)(A1 a1), A1 a1)
511  { std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFunc1<R,T,A1>(pmf,a1))); }
512 
513  template <typename C, typename R, typename T>
514  void apply2nd(C& object, R (T::*pmf)() const)
515  { std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFuncConst<R,T>(pmf))); }
516 
517  template <typename C, typename R, typename T, typename A1>
518  void apply2nd(C object, R (T::*pmf)(A1 a1) const, A1 a1)
519  { std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFuncConst1<R,T,A1>(pmf,a1))); }
520 
522 
526  template <typename T> class ReferenceBitMask {
527  public:
529  T& mask;
531  ReferenceBitMask(T& m);
532  T value() const {
533  return mask;
534  }
535  void set(const T& m) {
536  mask |= m;
537  }
538  void clear(const T& m) {
539  mask &= ~m;
540  }
541  void clear() {
542  mask = 0;
543  }
544  bool isSet(const T& m) const {
545  return (mask&m) == m;
546  }
547  bool anySet(const T& m) const {
548  return (mask&m) != 0;
549  }
550  bool testBit(int bit) const {
551  T m = T(1)<<bit;
552  return isSet(m);
553  }
554  bool isNull() const {
555  return mask == 0;
556  }
557  };
559  template <typename T> ReferenceBitMask<T>::ReferenceBitMask(T& m) : mask(m) {}
560 
561  /*
562  * Geometry namespace declaration
563  */
564  namespace Geometry {
565 
566  // Put here global basic type defintiions derived from primitive types of the Geometry namespace
567 
568  }// End namespace Geometry
569 } // End namespace DD4hep
570 #endif // DD4HEP_DD4HEP_PRIMITIVES_H
std::pair< std::string, value_t > string_pair_t
Definition of the string mapped type.
Definition: Primitives.h:124
T::second_type result_t
Definition: Primitives.h:260
invalid_handle_exception(const invalid_handle_exception &e)
Generic copy constructor.
Definition: Primitives.h:72
void operator()(std::pair< typename M::key_type const, typename M::mapped_type > &p) const
Definition: Primitives.h:493
Member function call-functor with 2 arguments (const version)
Definition: Primitives.h:420
long long int CellID
Useful typedefs to differentiate cell IDs and volume IDs.
Definition: Primitives.h:32
R(T::* memfunc_t)(A1 a1) const
Definition: Primitives.h:412
std::pair< unsigned long, value_t > ulong_pair_t
Definition of the unsigned long integer mapped type.
Definition: Primitives.h:120
const FCN & func
Definition: Primitives.h:491
R(T::* memfunc_t)(A1 a1)
Definition: Primitives.h:385
ApplyMemFuncConst2(memfunc_t f, A1 &a1, A2 &a2)
Definition: Primitives.h:425
R(T::* memfunc_t)(A1 a1, A2 a2)
Definition: Primitives.h:394
void deletePtr(T *&p)
Helper to delete objects from heap and reset the pointer. Saves many many lines of code...
Definition: Primitives.h:234
void deleteObject(T *p)
Helper to delete objects from heap and reset the pointer. Saves many many lines of code...
Definition: Primitives.h:240
void operator()(T *p) const
Definition: Primitives.h:389
const result_t & operator()(const arg_t &p) const
Operator function.
Definition: Primitives.h:262
void notImplemented(const std::string &msg)
Throw exception when handles are check for validity.
Definition: Primitives.cpp:207
map Functor to delete objects from heap
Definition: Primitives.h:282
Functor to release objects from heap and reset the pointer.
Definition: Primitives.h:323
void set(const T &m)
Definition: Primitives.h:535
void operator()(T &p) const
Definition: Primitives.h:325
Generic map Functor to act on first element (key)
Definition: Primitives.h:456
const void * abi_class
Definition: Primitives.h:177
void operator()(const T *p) const
Definition: Primitives.h:416
T operator()(T p) const
Definition: Primitives.h:355
static const char * format()
Access to the specific printf format. May be overloaded by users.
Definition: Primitives.h:148
ReleaseObject< typename M::value_type > releaseObject(M &)
Definition: Primitives.h:341
static void * _cast(const void *p)
Definition: Primitives.h:192
Operator to select second element of a pair.
Definition: Primitives.h:257
bool isNull() const
Definition: Primitives.h:554
invalid_handle_exception(const std::string &msg)
Initializing constructor.
Definition: Primitives.h:68
void apply2nd(C &object, const FCN &func)
Definition: Primitives.h:502
const result_t & operator()(const arg_t &p) const
Operator function.
Definition: Primitives.h:274
Select2nd< typename T::value_type > select2nd(const T &)
Generator to create Operator to select value elements of a map.
Definition: Primitives.h:265
std::map< std::string, value_t > string_map_t
Definition of the string mapped type.
Definition: Primitives.h:141
std::string typeName(const std::type_info &type)
ABI information about type names.
Definition: Primitives.cpp:186
static const std::type_info & type()
Access to the RTTI data type.
Definition: Primitives.h:150
Member function call-functor with 1 argument (const version)
Definition: Primitives.h:411
void(* destroy_t)(void *)
Definition: Primitives.h:170
void operator()(T *p) const
Definition: Primitives.h:399
ApplyMemFunc2(memfunc_t f, A1 &a1, A2 &a2)
Definition: Primitives.h:398
void release2nd(M &m)
Definition: Primitives.h:347
static void _destroy(void *p)
Definition: Primitives.h:188
TGeoShape * s
Definition: Volumes.cpp:294
void operator()(std::pair< typename M::key_type, typename M::mapped_type > p) const
Definition: Primitives.h:334
std::pair< unsigned int, value_t > uint_pair_t
Definition of the unsigned integer mapped type.
Definition: Primitives.h:116
return e
Definition: Volumes.cpp:297
Generic map Functor to act on second element (mapped type)
Definition: Primitives.h:489
Data structure to manipulate a bitmask held by reference and represented by an integer.
Definition: Primitives.h:526
Apply1rst(const FCN &f)
Definition: Primitives.h:459
std::map< unsigned short, value_t > ushort_map_t
Definition of the unsigned short integer mapped type.
Definition: Primitives.h:129
ApplyMemFunc1(memfunc_t f, A1 &a1)
Definition: Primitives.h:388
void operator()(const T *p) const
Definition: Primitives.h:426
ReferenceObject< M > referenceObject(M &)
Definition: Primitives.h:368
std::map< int, value_t > int_map_t
Definition of the integer mapped type.
Definition: Primitives.h:131
Apply1rst< C, FCN > apply__1rst_value(C &, const FCN &func)
Definition: Primitives.h:466
T::first_type result_t
Definition: Primitives.h:272
void operator()(const std::pair< typename M::key_type const, typename M::mapped_type > &p) const
Definition: Primitives.h:462
void releasePtr(T &p)
Helper to delete objects from heap and reset the pointer. Saves many many lines of code...
Definition: Primitives.h:316
Functor to delete objects from heap and reset the pointer.
Definition: Primitives.h:352
DestroyObjects< M > destroy2nd(M &m)
Definition: Primitives.h:295
virtual ~ComponentCast()
Defautl destructor.
Definition: Primitives.cpp:289
std::vector< value_t > vector_t
Definition of the vector type.
Definition: Primitives.h:107
Functor to delete objects from heap and reset the pointer.
Definition: Primitives.h:249
void operator()(T *p) const
Definition: Primitives.h:380
static const char * default_format()
Access to default printf format.
ApplyMemFuncConst1(memfunc_t f, A1 &a1)
Definition: Primitives.h:415
void invalidHandleAssignmentError(const std::type_info &from, const std::type_info &to)
Throw exception when handles are badly assigned.
Definition: Primitives.cpp:195
bool anySet(const T &m) const
Definition: Primitives.h:547
void copyObject(void *target, const void *source)
Helper to copy objects.
Definition: Primitives.h:225
T value_t
Type decribed by th class.
Definition: Primitives.h:105
void destroyObjects(M &m)
Definition: Primitives.h:293
Member function call-functor with no arguments (const version)
Definition: Primitives.h:403
std::map< size_t, value_t > size_map_t
Definition of the size_t mapped type.
Definition: Primitives.h:139
const FCN & func
Definition: Primitives.h:458
void * apply_dynCast(const ComponentCast &to, const void *ptr) const
Apply cast using typeinfo instead of dynamic_cast.
Definition: Primitives.cpp:318
void clear(const T &m)
Definition: Primitives.h:538
Select1st< typename T::value_type > select1st(const T &)
Generator to create Operator to select key values of a map.
Definition: Primitives.h:277
void * apply_downCast(const ComponentCast &to, const void *ptr) const
Apply cast using typeinfo instead of dynamic_cast.
Definition: Primitives.cpp:367
void destroy1st(M &m)
Definition: Primitives.h:312
Specialized exception to be thrown if invalid handles are accessed.
Definition: Primitives.h:63
std::map< short, value_t > short_map_t
Definition of the short integer mapped type.
Definition: Primitives.h:127
std::numeric_limits< value_t > limits
Definition of the limits.
Definition: Primitives.h:143
void releaseObjects(M &m)
Definition: Primitives.h:344
unsigned int hash(unsigned int initialSeed, unsigned int eventNumber, unsigned int runNumber)
calculate hash from initialSeed, eventID and runID
const std::type_info & type
Definition: Primitives.h:175
A bit of support for printing primitives.
Definition: Primitives.h:102
void *(* cast_t)(const void *)
Definition: Primitives.h:171
std::pair< long, value_t > long_pair_t
Definition of the long integer mapped type.
Definition: Primitives.h:118
Member function call-functor with 1 argument.
Definition: Primitives.h:384
Functor to delete objects from heap and reset the pointer.
Definition: Primitives.h:361
Map Functor to release objects from heap.
Definition: Primitives.h:330
Class to perform dynamic casts using unknown pointers.
Definition: Primitives.h:168
R(T::* memfunc_t)() const
Definition: Primitives.h:404
void apply1rst(C &object, const FCN &func)
Definition: Primitives.h:469
long int makeTime(int year, int month, int day, int hour=0, int minutes=0, int seconds=0)
Convert date into epoch time (seconds since 1970)
Definition: Primitives.cpp:32
std::pair< int, value_t > int_pair_t
Definition of the integer mapped type.
Definition: Primitives.h:114
result_t operator()(const M &p) const
Definition: Primitives.h:364
unsigned int hash32(const char *key)
We need it so often: one-at-time 32 bit hash function.
Definition: Primitives.h:39
std::pair< size_t, value_t > size_pair_t
Definition of the size_t mapped type.
Definition: Primitives.h:122
R(T::* memfunc_t)(A1 a1, A2 a2) const
Definition: Primitives.h:421
void destroyObject(T *&p)
Helper to delete objects from heap and reset the pointer.
Definition: Primitives.h:245
Member function call-functor with no arguments.
Definition: Primitives.h:376
static ComponentCast & instance()
Definition: Primitives.h:197
std::pair< unsigned short, value_t > ushort_pair_t
Definition of the unsigned short integer mapped type.
Definition: Primitives.h:112
invalid_handle_exception(const std::exception &e)
Generic copy constructor.
Definition: Primitives.h:70
ComponentCast(const std::type_info &t, destroy_t d, cast_t c)
Initializing Constructor.
Definition: Primitives.cpp:276
std::map< long, value_t > long_map_t
Definition of the long integer mapped type.
Definition: Primitives.h:135
ApplyMemFuncConst(memfunc_t f)
Definition: Primitives.h:406
void operator()(std::pair< typename M::key_type, typename M::mapped_type > p) const
Definition: Primitives.h:303
long long int VolumeID
Definition: Primitives.h:35
std::map< unsigned long, value_t > ulong_map_t
Definition of the unsigned long integer mapped type.
Definition: Primitives.h:137
void operator()(const std::pair< typename M::key_type const, typename M::mapped_type > &p) const
Definition: Primitives.h:495
void invalidHandleError(const std::type_info &type)
Throw exception when handles are check for validity.
Definition: Primitives.cpp:190
void operator()(const T *p) const
Definition: Primitives.h:407
void * apply_upCast(const ComponentCast &to, const void *ptr) const
Apply cast using typeinfo instead of dynamic_cast.
Definition: Primitives.cpp:358
Member function call-functor with 2 arguments.
Definition: Primitives.h:393
static std::string toString(T value)
Auto conversion to string using the default format.
Definition: Primitives.cpp:237
void destroyFirst(M &m)
Definition: Primitives.h:310
Apply2nd(const FCN &f)
Definition: Primitives.h:492
void destructObject(T *p)
Helper to destruct objects. Note: The memory is NOT released!
Definition: Primitives.h:230
T & mask
Reference to the data.
Definition: Primitives.h:529
Operator to select the first element of a pair.
Definition: Primitives.h:269
void typeinfoCheck(const std::type_info &typ1, const std::type_info &typ2, const std::string &text="")
Check type infos for equivalence (dynamic casts) using ABI information.
Definition: Primitives.cpp:213
std::map< unsigned int, value_t > uint_map_t
Definition of the unsigned integer mapped type.
Definition: Primitives.h:133
std::pair< short, value_t > short_pair_t
Definition of the short integer mapped type.
Definition: Primitives.h:110
virtual ~invalid_handle_exception()=default
Default destructor of specialized exception.
map Functor to delete objects from heap
Definition: Primitives.h:299
bool isSet(const T &m) const
Definition: Primitives.h:544
bool testBit(int bit) const
Definition: Primitives.h:550
void operator()(T &p) const
Definition: Primitives.h:251
void operator()() const
Definition: Primitives.h:305
void call_member_func(C &object, R(T::*pmf)())
Definition: Primitives.h:430
ReferenceBitMask(T &m)
Standard constructor.
Definition: Primitives.h:559
void operator()(std::pair< typename M::key_type const, typename M::mapped_type > &p) const
Definition: Primitives.h:460
TGeoShape TGeoMedium * m
Definition: Volumes.cpp:294
ApplyMemFunc(memfunc_t f)
Definition: Primitives.h:379
void operator()() const
Definition: Primitives.h:336
invalid_handle_exception(const char *msg)
Initializing constructor.
Definition: Primitives.h:66
M::second_type result_t
Definition: Primitives.h:363
void operator()() const
Definition: Primitives.h:288
ReferenceObjects< typename M::value_type > reference2nd(M &)
Definition: Primitives.h:371
void operator()(std::pair< typename M::key_type, typename M::mapped_type > p) const
Definition: Primitives.h:286
Apply2nd< C, FCN > apply__2nd_value(C &, const FCN &func)
Definition: Primitives.h:499
static std::string type_name()
Access to the RTTI data type.
Definition: Primitives.h:152