Primitives.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DD4HEP_DD4HEP_PRIMITIVES_H
#define DD4HEP_DD4HEP_PRIMITIVES_H

// C/C++ include files
#include <map>
#include <vector>
#include <string>
#include <limits>

#include <typeinfo>
#include <algorithm>
#include <stdexcept>

namespace DD4hep {

  namespace DDSegmentation  {
    class BitField64;
    class BitFieldValue;
    typedef long long int CellID;
    typedef long long int VolumeID;
  }

  inline unsigned int hash32(const char* key) {
    unsigned int hash = 0;
    const char* k = key;
    for (; *k; k++) {
      hash += *k;
      hash += (hash << 10);
      hash ^= (hash >> 6);
    }
    hash += (hash << 3);
    hash ^= (hash >> 11); hash += (hash << 15);
    return hash;
  }
  inline unsigned int hash32(const std::string& key) {
    return hash32(key.c_str());
  }

  long int makeTime(int year, int month, int day,
                    int hour=0, int minutes=0, int seconds=0);
  
  long int makeTime(const std::string& date, const char* fmt="%d-%m-%Y %H:%M:%S");
  
  class invalid_handle_exception : public std::runtime_error  {
  public:
    invalid_handle_exception(const char* msg) : std::runtime_error(msg) {}
    invalid_handle_exception(const std::string& msg) : std::runtime_error(msg) {}
    invalid_handle_exception(const std::exception& e) : std::runtime_error(e.what()) {}
    invalid_handle_exception(const invalid_handle_exception& e) : std::runtime_error(e.what()) {}
    virtual ~invalid_handle_exception() = default;
  };

  std::string typeName(const std::type_info& type);
  void typeinfoCheck(const std::type_info& typ1, const std::type_info& typ2, const std::string& text = "");
  void invalidHandleError(const std::type_info& type);
  void invalidHandleAssignmentError(const std::type_info& from, const std::type_info& to);

  template <typename T> void invalidHandleError()  {
    invalidHandleError(typeid(T));
  }

  void notImplemented(const std::string& msg);



  template<typename T> struct Primitive {
  public:
    typedef T value_t;
    typedef std::vector<value_t>             vector_t;

    typedef std::pair<short,value_t>          short_pair_t;
    typedef std::pair<unsigned short,value_t> ushort_pair_t;
    typedef std::pair<int,value_t>            int_pair_t;
    typedef std::pair<unsigned int,value_t>   uint_pair_t;
    typedef std::pair<long,value_t>           long_pair_t;
    typedef std::pair<unsigned long,value_t>  ulong_pair_t;
    typedef std::pair<size_t,value_t>         size_pair_t;
    typedef std::pair<std::string,value_t>    string_pair_t;

    typedef std::map<short,value_t>          short_map_t;
    typedef std::map<unsigned short,value_t> ushort_map_t;
    typedef std::map<int,value_t>            int_map_t;
    typedef std::map<unsigned int,value_t>   uint_map_t;
    typedef std::map<long,value_t>           long_map_t;
    typedef std::map<unsigned long,value_t>  ulong_map_t;
    typedef std::map<size_t,value_t>         size_map_t;
    typedef std::map<std::string,value_t>    string_map_t;
    typedef std::numeric_limits<value_t>     limits;

    static const char* default_format(); 
    static const char* format()          { return default_format();     }
    static const std::type_info& type()  { return typeid(value_t);      }
    static std::string type_name()       { return typeName(type());     }
    static std::string toString(T value);
  };



  class ComponentCast {
  public:
    typedef void  (*destroy_t)(void*);
    typedef void* (*cast_t)(const void*);
#ifdef __CINT__
    const std::type_info* type;
#else
    const std::type_info& type;
#endif
    const void* abi_class;
    destroy_t   destroy;
    cast_t      cast;

  private:
    ComponentCast(const std::type_info& t, destroy_t d, cast_t c);
    virtual ~ComponentCast();

  public:
    template <typename TYPE> static void _destroy(void* p)  {
      TYPE* q = (TYPE*)p;
      if (q)    delete q;
    }
    template <typename TYPE> static void* _cast(const void* p)  {
      TYPE* q = (TYPE*)p;
      q = dynamic_cast<TYPE*>(q);
      return (void*)q;
    }
    template <typename TYPE> static ComponentCast& instance() {
      static ComponentCast c(typeid(TYPE),_destroy<TYPE>,_cast<TYPE>);
      return c;
    }

    void* apply_dynCast(const ComponentCast& to, const void* ptr) const;
    void* apply_upCast(const ComponentCast& to, const void* ptr) const;
    void* apply_downCast(const ComponentCast& to, const void* ptr) const;
  };


  // Put here global basic type definitions derived from primitive types of the DD4hep namespace
#ifdef __CINT__
  typedef DDSegmentation::CellID CellID;
  typedef DDSegmentation::VolumeID VolumeID;
  typedef DDSegmentation::BitField64 BitField64;
  typedef DDSegmentation::BitFieldValue BitFieldValue;
#else
  using DDSegmentation::CellID;
  using DDSegmentation::VolumeID;
  using DDSegmentation::BitField64;
  using DDSegmentation::BitFieldValue;
#endif

  template <typename T> inline void copyObject(void* target,const void* source)  {
    const T* s = (const T*)source;
    ::new(target) T(*s);
  }
  template <typename T> inline void destructObject(T* p) {
    p->~T();
  }
  template <typename T> inline void deletePtr(T*& p) {
    if (0 != p)
      delete p;
    p = 0;
  }
  template <typename T> inline void deleteObject(T* p) {
    if (0 != p)
      delete p;
  }
  template <typename T> inline void destroyObject(T*& p) {
    deletePtr(p);
  }
  template <typename T> class DestroyObject {
  public:
    void operator()(T& p) const {
      destroyObject(p);
    }
  };

  template <typename T> class Select2nd  {
  public:
    typedef T arg_t;
    typedef typename T::second_type result_t;
    const result_t& operator()(const arg_t &p) const { return p.second; }
  };
  template <typename T> Select2nd<typename T::value_type> select2nd(const T&)
  { return Select2nd<typename T::value_type>(); }

  template <typename T> class Select1st  {
  public:
    typedef T arg_t;
    typedef typename T::first_type result_t;
    const result_t& operator()(const arg_t &p) const { return p.first; }
  };
  template <typename T> Select1st<typename T::value_type> select1st(const T&)
  { return Select1st<typename T::value_type>(); }


  template <typename M> class DestroyObjects {
  public:
    M& object;
    DestroyObjects(M& m) : object(m) {                    }
    void operator()(std::pair<typename M::key_type, typename M::mapped_type> p) const
    {  DestroyObject<typename M::mapped_type>()(p.second);    }
    void operator()() const {
      if ( !object.empty() ) for_each(object.begin(),object.end(),(*this));
      object.clear();
    }
  };
  template <typename M> void destroyObjects(M& m)
  {  DestroyObjects<M> del(m); del();                      }
  template <typename M> DestroyObjects<M> destroy2nd(M& m)
  {  DestroyObjects<M> del(m); del();                      }

  template <typename M> class DestroyFirst {
  public:
    M& object;
    DestroyFirst(M& m) : object(m) {   }
    void operator()(std::pair<typename M::key_type, typename M::mapped_type> p) const
    {  DestroyObject<typename M::key_type>()(p.first);     }
    void operator()() const {
      if ( !object.empty() ) for_each(object.begin(),object.end(),(*this));
      object.clear();
    }
  };
  template <typename M> void destroyFirst(M& m)
  {   DestroyFirst<M> del(m); del();           }
  template <typename M> void destroy1st(M& m)
  {   DestroyFirst<M> del(m); del();           }

  template <typename T> inline void releasePtr(T& p) {
    if (0 != p)
      p->release();
    p = 0;
  }

  template <typename T> class ReleaseObject {
  public:
    void operator()(T& p) const {
      releasePtr(p);
    }
  };
  template <typename M> class ReleaseObjects {
  public:
    M& object;
    ReleaseObjects(M& m) : object(m) {    }
    void operator()(std::pair<typename M::key_type, typename M::mapped_type> p) const
    {  ReleaseObject<typename M::mapped_type>()(p.second);    }
    void operator()() const {
      if ( !object.empty() ) for_each(object.begin(),object.end(),(*this));
      object.clear();
    }
  };
  template <typename M> ReleaseObject<typename M::value_type> releaseObject(M&) {
    return ReleaseObject<typename M::value_type>();
  }
  template <typename M> void releaseObjects(M& m) {
    ReleaseObjects<M> rel(m); rel();
  }
  template <typename M> void release2nd(M& m) {
    ReleaseObjects<M> rel(m); rel();
  }

  template <typename T> class ReferenceObject {
  public:
    typedef T arg_t;
    T operator()(T p) const {
      if ( p ) p->addRef();
      return p;
    }
  };
  template <typename M> class ReferenceObjects {
  public:
    typedef typename M::second_type result_t;
    result_t operator()(const M& p) const {
      return ReferenceObject<result_t>()(p.second);
    }
  };
  template <typename M> ReferenceObject<M> referenceObject(M&) {
    return ReferenceObject<typename M::value_type>();
  }
  template <typename M> ReferenceObjects<typename M::value_type> reference2nd(M&) {
    return ReferenceObjects<typename M::value_type>();
  }

  template <typename R, typename T> struct ApplyMemFunc {
    typedef R (T::*memfunc_t)();
    memfunc_t func;
    ApplyMemFunc(memfunc_t f) : func(f)  {}
    void operator()(T* p)  const {  if (p) { (p->*func)(); } }
  };

  template <typename R, typename T, typename A1> struct ApplyMemFunc1 {
    typedef R (T::*memfunc_t)(A1 a1);
    memfunc_t func;
    A1& arg1;
    ApplyMemFunc1(memfunc_t f, A1& a1) : func(f), arg1(a1)  {}
    void operator()(T* p)  const {  if ( p ) { (p->*func)(arg1); } }
  };

  template <typename R, typename T, typename A1, typename A2> struct ApplyMemFunc2 {
    typedef R (T::*memfunc_t)(A1 a1, A2 a2);
    memfunc_t func;
    A1& arg1;
    A2& arg2;
    ApplyMemFunc2(memfunc_t f, A1& a1, A2& a2) : func(f), arg1(a1), arg2(a2)  {}
    void operator()( T* p)  const {  if ( p ) { (p->*func)(arg1, arg2); } }
  };

  template <typename R, typename T> struct ApplyMemFuncConst {
    typedef R (T::*memfunc_t)() const;
    memfunc_t func;
    ApplyMemFuncConst(memfunc_t f) : func(f)  {}
    void operator()(const T* p)  const {  if ( p ) { (p->*func)(); } }
  };

  template <typename R, typename T, typename A1> struct ApplyMemFuncConst1 {
    typedef R (T::*memfunc_t)(A1 a1) const;
    memfunc_t func;
    A1& arg1;
    ApplyMemFuncConst1(memfunc_t f, A1& a1) : func(f), arg1(a1)  {}
    void operator()(const T* p)  const {  if ( p ) { (p->*func)(arg1); } }
  };

  template <typename R, typename T, typename A1, typename A2> struct ApplyMemFuncConst2 {
    typedef R (T::*memfunc_t)(A1 a1, A2 a2) const;
    memfunc_t func;
    A1& arg1;
    A2& arg2;
    ApplyMemFuncConst2(memfunc_t f, A1& a1, A2& a2) : func(f), arg1(a1), arg2(a2)  {}
    void operator()(const T* p)  const {  if ( p ) { (p->*func)(arg1, arg2); } }
  };

  template <typename C, typename R, typename T>
  void call_member_func(C& object, R (T::*pmf)())
  {   std::for_each(object.begin(),object.end(),ApplyMemFunc<R,T>(pmf));    }

  template <typename C, typename R, typename T>
  void call_member_func(C& object, R (T::*pmf)() const)
  {   std::for_each(object.begin(),object.end(),ApplyMemFuncConst<R,T>(pmf));    }

  template <typename C, typename R, typename T, typename A1>
  void call_member_func(C& object, R (T::*pmf)(A1 a1), A1 a1)
  {   std::for_each(object.begin(),object.end(),ApplyMemFunc1<R,T,A1>(pmf,a1));    }
  
  template <typename C, typename R, typename T, typename A1>
  void call_member_func(C& object, R (T::*pmf)(A1 a1) const, A1 a1)
  {   std::for_each(object.begin(),object.end(),ApplyMemFuncConst1<R,T,A1>(pmf,a1));    }
  
  
  template <typename C, typename R, typename T, typename A1, typename A2>
  void call_member_func(C& object, R (T::*pmf)(A1 a1,A2 a2), A1 a1, A2 a2)
  {   std::for_each(object.begin(),object.end(),ApplyMemFunc2<R,T,A1,A2>(pmf,a1,a2));    }
  
  template <typename C, typename R, typename T, typename A1, typename A2>
  void call_member_func(C& object, R (T::*pmf)(A1 a1,A2 a2) const, A1 a1, A2 a2)
  {   std::for_each(object.begin(),object.end(),ApplyMemFuncConst2<R,T,A1,A2>(pmf,a1,a2));    }
  

  template <typename M, typename FCN> class Apply1rst {
  public:
    const FCN& func;
    Apply1rst(const FCN& f) : func(f) {    }
    void operator()(std::pair<typename M::key_type const, typename M::mapped_type>& p) const
    {   (func)(p.first);    }
    void operator()(const std::pair<typename M::key_type const, typename M::mapped_type>& p) const
    {   (func)(p.first);    }
  };

  template <typename C, typename FCN> Apply1rst<C,FCN> apply__1rst_value(C&,const FCN& func)
  {  return Apply1rst<C,FCN>(func);  }

  template <typename C, typename FCN> void apply1rst(C& object,const FCN& func)
  {  std::for_each(object.begin(),object.end(),apply__1rst_value(object,func));  }

  template <typename C, typename R, typename T>
  void apply1rst(C& object, R (T::*pmf)())  
  {  std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFunc<R,T>(pmf)));  }

  template <typename C, typename R, typename T, typename A1>
  void apply1rst(C object, R (T::*pmf)(A1 a1), A1 a1)
  {  std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFunc1<R,T,A1>(pmf,a1)));  }

  template <typename C, typename R, typename T>
  void apply1rst(C& object, R (T::*pmf)() const)  
  {  std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFuncConst<R,T>(pmf)));  }

  template <typename C, typename R, typename T, typename A1>
  void apply1rst(C object, R (T::*pmf)(A1 a1) const, A1 a1)
  {  std::for_each(object.begin(),object.end(),apply__1rst_value(object,ApplyMemFuncConst1<R,T,A1>(pmf,a1)));  }

  template <typename M, typename FCN> class Apply2nd {
  public:
    const FCN& func;
    Apply2nd(const FCN& f) : func(f) {    }
    void operator()(std::pair<typename M::key_type const, typename M::mapped_type>& p) const
    {   (func)(p.second);    }
    void operator()(const std::pair<typename M::key_type const, typename M::mapped_type>& p) const
    {   (func)(p.second);    }
  };

  template <typename C, typename FCN> Apply2nd<C,FCN> apply__2nd_value(C&,const FCN& func)
  {  return Apply2nd<C,FCN>(func);  }

  template <typename C, typename FCN> void apply2nd(C& object,const FCN& func)
  {  std::for_each(object.begin(),object.end(),apply__2nd_value(object,func));  }

  template <typename C, typename R, typename T>
  void apply2nd(C& object, R (T::*pmf)())  
  {  std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFunc<R,T>(pmf)));  }

  template <typename C, typename R, typename T, typename A1>
  void apply2nd(C object, R (T::*pmf)(A1 a1), A1 a1)
  {  std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFunc1<R,T,A1>(pmf,a1)));  }

  template <typename C, typename R, typename T>
  void apply2nd(C& object, R (T::*pmf)() const)  
  {  std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFuncConst<R,T>(pmf)));  }

  template <typename C, typename R, typename T, typename A1>
  void apply2nd(C object, R (T::*pmf)(A1 a1) const, A1 a1)
  {  std::for_each(object.begin(),object.end(),apply__2nd_value(object,ApplyMemFuncConst1<R,T,A1>(pmf,a1)));  }


  template <typename T> class ReferenceBitMask  {
  public:
    T& mask;
    ReferenceBitMask(T& m);
    T value() const  {
      return mask;
    }
    void set(const T& m)   {
      mask |= m;
    }
    void clear(const T& m)   {
      mask &= ~m;
    }
    void clear()   {
      mask = 0;
    }
    bool isSet(const T& m)  const {
      return (mask&m) == m;
    }
    bool anySet(const T& m)  const {
      return (mask&m) != 0;
    }
    bool testBit(int bit) const  {
      T m = T(1)<<bit;
      return isSet(m);
    }
    bool isNull() const {
      return mask == 0;
    }
  };
  template <typename T>  ReferenceBitMask<T>::ReferenceBitMask(T& m) : mask(m) {}

  /*
   *   Geometry namespace declaration
   */
  namespace Geometry {

    // Put here global basic type defintiions derived from primitive types of the Geometry namespace

  }// End namespace Geometry
}      // End namespace DD4hep
#endif // DD4HEP_DD4HEP_PRIMITIVES_H