Handle.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// 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_HANDLE_H
#define DD4HEP_HANDLE_H
 
// Framework include files
#include <DD4hep/Primitives.h>
 
#include <string>
#include <typeinfo>
#include <stdexcept>
#include <type_traits>
 
// Conversion factor from radians to degree: 360/(2*PI)
#ifndef RAD_2_DEGREE
#define RAD_2_DEGREE 57.295779513082320876798154814105
#endif
#ifndef DEGREE_2_RAD
#define DEGREE_2_RAD 0.0174532925199432957692369076848
#endif
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
namespace dd4hep {
 
  // Forward declarations
  class NamedObject;
 
  bool set_allow_variable_redefine(bool value);
 
  long num_object_validations();
  void increment_object_validations();
 
  void warning_deprecated_xml_factory(const char* name);
 
 
  inline unsigned long long int magic_word() {
    return 0xFEEDAFFEDEADFACEULL;
  }
 
 
  template <typename T> class Handle {
  public:
    typedef T Object;
    typedef Handle<T> Base;
    
    T* m_element  {nullptr};
 
    Handle() = default;
    Handle(Handle<T>&& element) = default;
    Handle(const Handle<T>& element) = default;
    Handle(T* element) : m_element(element)   {            }
    template <typename Q> Handle(Q* element)
      : m_element(element ? detail::safe_cast<T>::cast(element) : 0)
    {             }
    template <typename Q> Handle(const Handle<Q>& element)
      : m_element(element.m_element ? detail::safe_cast<T>::cast(element.m_element) : 0)
    {             }
    Handle<T>& operator=(Handle<T>&& element) = default;
    Handle<T>& operator=(const Handle<T>& element) = default;
    bool operator==(const Handle<T>& element)  const {
      return m_element == element.m_element;
    }
    bool operator<(const Handle<T>& element)  const  {
      return m_element < element.m_element;
    }
    bool operator>(const Handle<T>& element)  const  {
      return m_element > element.m_element;
    }
    bool isValid() const   {
      return 0 != m_element;
    }
    bool operator!() const   {
      return 0 == m_element;
    }
    Handle<T>& clear() {
      m_element = 0;
      return *this;
    }
    T* operator->() const {
      return m_element;
    }
    operator T&() const {
      return *m_element;
    }
    T& operator*() const {
      return *m_element;
    }
    T* ptr() const {
      return m_element;
    }
    template <typename Q> Q* _ptr() const {
      return (Q*) m_element;
    }
    template <typename Q> Q* data() const {
      return (Q*) m_element;
    }
    template <typename Q> Q& object() const {
      return *(Q*) m_element;
    }
 
    T* access() const;
    const char* name() const;
    void assign(Object* n, const std::string& nam, const std::string& title);
    void destroy();
    static void bad_assignment(const std::type_info& from, const std::type_info& to);
  };
  typedef Handle<NamedObject> Ref_t;
  namespace detail  {
    template <typename T> inline void destroyHandle(T& handle) {
      deletePtr(handle.m_element);
    }
    template <typename T> class DestroyHandle {
    public:
      void operator()(T ptr) const {  destroyHandle(ptr);    }
    };
    template <typename M> class DestroyHandles {
    public:
      M& object;
      DestroyHandles(M& obj) : object(obj) {                 }
      void operator()(const std::pair<typename M::key_type, typename M::mapped_type>& arg) const
      {   DestroyHandle<typename M::mapped_type>()(arg.second);    }
    };
    template <typename M> void destroyHandles(M& arg)  {
      for_each(arg.begin(), arg.end(), DestroyHandles<M>(arg));
      arg.clear();
    }
 
    template <typename T> inline void releaseHandle(T& handle) {
      releasePtr(handle.m_element);
    }
    template <typename T> class ReleaseHandle {
    public:
      void operator()(T handle) const {  releaseHandle(handle);    }
    };
    template <typename M> class ReleaseHandles {
    public:
      M& object;
      ReleaseHandles(M& obj) : object(obj) {                 }
      void operator()(const std::pair<typename M::key_type, typename M::mapped_type>& arg) const
      {   ReleaseHandle<typename M::mapped_type>()(arg.second);    }
    };
    template <typename M> void releaseHandles(M& arg)  {
      for_each(arg.begin(), arg.end(), ReleaseHandles<M>(arg));
      arg.clear();
    }
  }
  
  std::string remove_whitespace(const std::string& v);
 
  std::string _toString(bool value);
  std::string _toString(short value, const char* fmt = "%d");
  std::string _toString(int value, const char* fmt = "%d");
  std::string _toString(unsigned long value, const char* fmt = "%ld");
  std::string _toString(float value, const char* fmt = "%.17e");
  std::string _toString(double value, const char* fmt = "%.17e");
  std::string _ptrToString(const void* p, const char* fmt = "%p");
  template <typename T> std::string _toString(const T* p, const char* fmt = "%p")
  {      return _ptrToString((void*)p, fmt);       }
 
  template <typename T> T _toType(const std::string& value);
  
  bool   _toBool(const std::string& value);
  short  _toShort(const std::string& value);
  int    _toInt(const std::string& value);
  long   _toLong(const std::string& value);
  unsigned short _toUShort(const std::string& value);
  unsigned int   _toUInt(const std::string& value);
  unsigned long  _toULong(const std::string& value);
  float  _toFloat(const std::string& value);
  double _toDouble(const std::string& value);
 
  inline bool _toBool(bool value) {
    return value;
  }
  inline short _toShort(short value) {
    return value;
  }
  inline int _toInt(int value) {
    return value;
  }
  inline long _toLong(long value) {
    return value;
  }
  inline unsigned short _toUShort(unsigned short value) {
    return value;
  }
  inline unsigned int _toUInt(unsigned int value) {
    return value;
  }
  inline unsigned long _toULong(unsigned long value) {
    return value;
  }
  inline float _toFloat(float value) {
    return value;
  }
  inline double _toDouble(double value) {
    return value;
  }
 
  template <class T> T _multiply(const std::string& left, T right);
  template <class T> T _multiply(T left, const std::string& right);
  template <class T> T _multiply(const std::string& left, const std::string& right);
 
  template <> char _multiply<char>(const std::string& left, const std::string& right);
  template <> inline char _multiply<char>(char left, const std::string& right) {
    return left * _toInt(right);
  }
  template <> inline char _multiply<char>(const std::string& left, char right) {
    return _toInt(left) * right;
  }
 
  template <> unsigned char _multiply<unsigned char>(const std::string& left, const std::string& right);
  template <> inline unsigned char _multiply<unsigned char>(unsigned char left, const std::string& right) {
    return left * _toInt(right);
  }
  template <> inline unsigned char _multiply<unsigned char>(const std::string& left, unsigned char right) {
    return _toInt(left) * right;
  }
 
  template <> short _multiply<short>(const std::string& left, const std::string& right);
  template <> inline short _multiply<short>(short left, const std::string& right) {
    return left * _toInt(right);
  }
  template <> inline short _multiply<short>(const std::string& left, short right) {
    return _toInt(left) * right;
  }
 
  template <> unsigned short _multiply<unsigned short>(const std::string& left, const std::string& right);
  template <> inline unsigned short _multiply<unsigned short>(unsigned short left, const std::string& right) {
    return left * _toInt(right);
  }
  template <> inline unsigned short _multiply<unsigned short>(const std::string& left, unsigned short right) {
    return _toInt(left) * right;
  }
 
  template <> int _multiply<int>(const std::string& left, const std::string& right);
  template <> inline int _multiply<int>(int left, const std::string& right) {
    return left * _toInt(right);
  }
  template <> inline int _multiply<int>(const std::string& left, int right) {
    return _toInt(left) * right;
  }
 
  template <> unsigned int _multiply<unsigned int>(const std::string& left, const std::string& right);
  template <> inline unsigned int _multiply<unsigned int>(unsigned int left, const std::string& right) {
    return left * _toInt(right);
  }
  template <> inline unsigned int _multiply<unsigned int>(const std::string& left, unsigned int right) {
    return _toInt(left) * right;
  }
 
  template <> long _multiply<long>(const std::string& left, const std::string& right);
  template <> inline long _multiply<long>(long left, const std::string& right) {
    return left * _toLong(right);
  }
  template <> inline long _multiply<long>(const std::string& left, long right) {
    return _toLong(left) * right;
  }
 
  template <> unsigned long _multiply<unsigned long>(const std::string& left, const std::string& right);
  template <> inline unsigned long _multiply<unsigned long>(unsigned long left, const std::string& right) {
    return left * _toLong(right);
  }
  template <> inline unsigned long _multiply<unsigned long>(const std::string& left, unsigned long right) {
    return _toLong(left) * right;
  }
 
  template <> float _multiply<float>(const std::string& left, const std::string& right);
  template <> inline float _multiply<float>(float left, const std::string& right) {
    return left * _toFloat(right);
  }
  template <> inline float _multiply<float>(const std::string& left, float right) {
    return _toFloat(left) * right;
  }
 
  template <> double _multiply<double>(const std::string& left, const std::string& right);
  template <> inline double _multiply<double>(const std::string& left, double right) {
    return _toDouble(left) * right;
  }
  template <> inline double _multiply<double>(double left, const std::string& right) {
    return left * _toDouble(right);
  }
 
  void _toDictionary(const std::string& name, const std::string& value);
  void _toDictionary(const std::string& name, const std::string& value, const std::string& typ);
 
  namespace detail {
    using dd4hep::Handle;
    using dd4hep::Ref_t;
  } /* End namespace detail  */
  
  // Forward declarations
  class Detector;
}         /* End namespace dd4hep    */
#endif // DD4HEP_HANDLE_H