Handle.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_HANDLE_H
#define DD4HEP_HANDLE_H

// Framework include files
#include "DD4hep/config.h"
#include "DD4hep/Primitives.h"

#include <string>
#include <typeinfo>
#include <stdexcept>

// 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 CM_2_MM
#define CM_2_MM 10.0
#endif
#ifndef MM_2_CM
#define MM_2_CM 0.1
#endif

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

namespace DD4hep {

  // Forward declarations
  class NamedObject;

  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 Implementation;
    typedef Handle<Implementation> handle_t;

    T* m_element = 0;
    Handle() = default;
    Handle(const Handle<T>& e) = default;
    Handle(T* e) : m_element(e)   {            }
    template <typename Q> Handle(Q* e) : m_element((T*)e)
    {    verifyObject();                       }
    template <typename Q> Handle(const Handle<Q>& e) : m_element((T*)e.m_element)
    {    verifyObject();                       }
    Handle<T>& operator=(const Handle<T>& e) = default;
    bool operator==(const Handle<T>& e)  const {
      return m_element == e.m_element;
    }
    bool operator<(const Handle<T>& e)  const  {
      return m_element < e.m_element;
    }
    bool operator>(const Handle<T>& e)  const  {
      return m_element > e.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;
    void verifyObject() const;
    const char* name() const;
    void assign(Implementation* n, const std::string& nam, const std::string& title);
    static void bad_assignment(const std::type_info& from, const std::type_info& to);
  };
  typedef Handle<NamedObject> Ref_t;

  template <typename T> inline void destroyHandle(T& h) {
    deletePtr(h.m_element);
  }
  template <typename T> class DestroyHandle {
  public:
    void operator()(T p) const {  destroyHandle(p);    }
  };
  template <typename M> class DestroyHandles {
  public:
    M& object;
    DestroyHandles(M& m) : object(m) {                 }
    void operator()(const std::pair<typename M::key_type, typename M::mapped_type>& p) const
    {   DestroyHandle<typename M::mapped_type>()(p.second);    }
  };
  template <typename M> void destroyHandles(M& m)  {
    for_each(m.begin(), m.end(), DestroyHandles<M>(m));
    m.clear();
  }

  template <typename T> inline void releaseHandle(T& h) {
    releasePtr(h.m_element);
  }
  template <typename T> class ReleaseHandle {
  public:
    void operator()(T p) const {  releaseHandle(p);    }
  };
  template <typename M> class ReleaseHandles {
  public:
    M& object;
    ReleaseHandles(M& m) : object(m) {                 }
    void operator()(const std::pair<typename M::key_type, typename M::mapped_type>& p) const
    {   ReleaseHandle<typename M::mapped_type>()(p.second);    }
  };
  template <typename M> void releaseHandles(M& m)  {
    for_each(m.begin(), m.end(), ReleaseHandles<M>(m));
    m.clear();
  }

  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(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);       }

  bool   _toBool(const std::string& value);
  short  _toShort(const std::string& value);
  int    _toInt(const std::string& value);
  long   _toLong(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 Geometry {
    using DD4hep::Handle;
    using DD4hep::Ref_t;

    // Forward declarations
    class LCDD;
  } /* End namespace Geometry  */
}   /* End namespace DD4hep    */
#endif    /* DD4HEP_HANDLE_H       */