ConditionAny.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_CONDITIONANY_H
#define DD4HEP_CONDITIONANY_H
 
// Framework include files
#include <DD4hep/Conditions.h>
 
// C/C++ include files
#include <any>
 
namespace dd4hep {
 
  namespace detail  {
    class ConditionObject;
  }
 
 
  class ConditionAny : public Handle<detail::ConditionObject> {
  public:
    using key_type     = Condition::key_type;
    using detkey_type  = Condition::detkey_type;
    using itemkey_type = Condition::itemkey_type;
    using mask_type    = Condition::mask_type;
 
  private:
    void use_data(detail::ConditionObject* obj);
 
  public:
 
    ConditionAny() = default;
    ConditionAny(ConditionAny&& c) = default;
    ConditionAny(Condition&& c);
    ConditionAny(const ConditionAny& c) = default;
    ConditionAny(const Condition& c);
    ConditionAny(Object* p);
    template <typename Q> ConditionAny(const Handle<Q>& e);
    ConditionAny(key_type hash_key);
    template <typename PAYLOAD> ConditionAny(key_type hash_key, PAYLOAD&& data);
    ConditionAny(const std::string& name, const std::string& type);
    template <typename PAYLOAD> ConditionAny(const std::string& name, const std::string& type, PAYLOAD&& data);
 
    template <typename Q> ConditionAny& operator=(Handle<Q>&& c);
    template <typename Q> ConditionAny& operator=(const Handle<Q>& c);
    ConditionAny& operator=(Condition&& c);
    ConditionAny& operator=(const Condition& c);
    ConditionAny& operator=(ConditionAny&& c) = default;
    ConditionAny& operator=(const ConditionAny& c) = default;
 
    const IOVType& iovType()  const;
    const IOV& iov()  const;
 
    key_type key()  const;
    detkey_type  detector_key()  const;
    itemkey_type item_key()  const;
 
    mask_type flags()  const;
    void setFlag(mask_type option);
    void unFlag(mask_type option);
    bool testFlag(mask_type option) const;
 
    std::any& get();
    const std::any& get() const;
 
    bool has_value()   const;
    const std::type_info& any_type() const;
    const std::string     any_type_name() const;
    template <typename T> T& as();
    template <typename T> const T& as() const;
    template <typename T> T value();
    template <typename T> T* pointer();
    template <typename T> const T* pointer() const;
  };
 
  inline ConditionAny::ConditionAny(Condition&& c) : Handle<detail::ConditionObject>() {
    this->use_data(c.ptr());
  }
 
  inline ConditionAny::ConditionAny(const Condition& c) : Handle<detail::ConditionObject>()  {
    this->use_data(c.ptr());
  }
 
  template <typename PAYLOAD> inline 
    ConditionAny::ConditionAny(key_type hash_key, PAYLOAD&& payload)   {
    ConditionAny c(hash_key);
    c.get() = std::move(payload);
    this->m_element = c.ptr();
  }
 
  template <typename PAYLOAD> inline 
    ConditionAny::ConditionAny(const std::string& name, const std::string& type, PAYLOAD&& payload)   {
    ConditionAny c(name, type);
    c.get() = std::move(payload);
    this->m_element = c.ptr();
  }
 
  template <typename Q> inline ConditionAny& ConditionAny::operator=(Handle<Q>&& c)  {
    this->use_data(c.ptr());
    return *this;
  }
 
  template <typename Q> inline ConditionAny& ConditionAny::operator=(const Handle<Q>& c)   {
    this->use_data(c.ptr());
    return *this;
  }
 
  inline ConditionAny& ConditionAny::operator=(Condition&& c)  {
    this->use_data(c.ptr());
    return *this;
  }
 
  inline ConditionAny& ConditionAny::operator=(const Condition& c)   {
    this->use_data(c.ptr());
    return *this;
  }
 
  template <typename T> inline T ConditionAny::value() {
    return std::any_cast<T>(this->get());
  }
 
  template <typename T> inline T& ConditionAny::as() {
    T* ptr_payload = std::any_cast<T>(&this->get());
    if ( ptr_payload ) return *ptr_payload;
    throw std::runtime_error("ConditionAny: Cannot access value of std::any as a reference to "+typeName(typeid(T)));
  }
 
  template <typename T> inline const T& ConditionAny::as() const {
    const T* ptr_payload = std::any_cast<T>(&this->get());
    if ( ptr_payload ) return *ptr_payload;
    throw std::runtime_error("ConditionAny: Cannot access value of std::any as a reference to "+typeName(typeid(T)));
  }
 
  template <typename T> inline T* ConditionAny::pointer() {
    return isValid() ? std::any_cast<T>(&this->get()) : nullptr;
  }
 
  template <typename T> inline const T* ConditionAny::pointer() const {
    return isValid() ? std::any_cast<const T>(&this->get()) : nullptr;
  }
 
}          /* End namespace dd4hep                   */
#endif // DD4HEP_CONDITIONANY_H