ConditionDerived.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_CONDITIONDERIVED_H
#define DD4HEP_CONDITIONDERIVED_H
 
// Framework include files
#include <DD4hep/Memory.h>
#include <DD4hep/Conditions.h>
#include <DD4hep/detail/ConditionsInterna.h>
 
// C/C++ include files
#include <memory>
 
namespace dd4hep {
 
  class BasicGrammar;
 
  namespace cond   {
 
    class DependencyBuilder;
    class ConditionResolver;
    class ConditionDependency;
    class ConditionUpdateCall;
    class ConditionUpdateContext;
    class ConditionUpdateUserContext;
 
 
    class ConditionUpdateUserContext  {
    public:
      virtual ~ConditionUpdateUserContext();
    };
    
 
    class ConditionResolver   {
    public:
      virtual ~ConditionResolver();
      virtual Handle<NamedObject> manager() const = 0;
      virtual Detector& detectorDescription() const = 0;
      virtual const IOV& requiredValidity()  const = 0;
      virtual ConditionsMap& conditionsMap() const = 0;
      virtual Condition get(const ConditionKey& key) = 0;
      virtual Condition get(const ConditionKey& key, bool throw_if_not) = 0;
      virtual Condition get(Condition::key_type key) = 0;
      virtual Condition get(Condition::key_type key, bool throw_if_not) = 0;
      virtual Condition get(Condition::key_type key,
                            const ConditionDependency* dependency,
                            bool throw_if_not) = 0;
      virtual std::vector<Condition> get(DetElement de) = 0;
      virtual std::vector<Condition> get(Condition::detkey_type key) = 0;
      virtual std::vector<Condition> getByItem(Condition::itemkey_type key) = 0;
 
 
      virtual bool registerOne(const IOV& iov, Condition cond)  = 0;
      virtual size_t registerMany(const IOV& iov, const std::vector<Condition>& values) = 0;
      template <typename CONT> size_t registerUnmapped(const IOV& iov, CONT& c)   {
        std::vector<Condition> conditions;
        conditions.reserve(c.size());
        std::copy(std::begin(c), std::end(c), std::back_inserter(conditions));
        return this->registerMany(iov, conditions);
      }
      template <typename CONT> size_t registerMapping(const IOV& iov, CONT& c)     {
        std::vector<Condition> conditions;
        conditions.reserve(c.size());
        std::transform(std::begin(c), std::end(c), std::back_inserter(conditions), detail::get_2nd<CONT>());
        return this->registerMany(iov, conditions);
      }
    };
 
 
    class ConditionUpdateContext final  {
    public:
      ConditionResolver*          resolver;
      const ConditionDependency*  dependency;
      IOV*                        iov;
      ConditionUpdateUserContext* parameter;
 
    public:
      ConditionUpdateContext(ConditionResolver* r,
                             const ConditionDependency* d,
                             IOV* iov,
                             ConditionUpdateUserContext* parameter);
      
      void accessFailure(const ConditionKey& key_value)  const;
 
      Detector& detectorDescription() const   {
        return resolver->detectorDescription();
      }
 
      DetElement world()  const;
 
      const IOV& requiredValidity()  const   {
        return resolver->requiredValidity();
      }
 
      ConditionsMap& conditionsMap() const    {
        return resolver->conditionsMap();
      }
 
      const ConditionKey& key(size_t which)  const;
 
      template<typename Q> Q* param()  const  {
        return static_cast<Q*>(parameter);
      }
 
 
      std::vector<Condition> conditions(DetElement det)  const    {
        return conditions(det.key());
      }
 
 
      std::vector<Condition> conditions(Condition::detkey_type det_key)  const;
 
 
      std::vector<Condition> getByItem(Condition::itemkey_type key)   const;
 
 
      Condition condition(const ConditionKey& key_value)  const;
 
 
      Condition condition(Condition::key_type key_value)  const;
 
 
      Condition condition(Condition::key_type key_value, bool throw_if_not)  const;
 
 
      template<typename T> T& get(const ConditionKey& key_value);
 
 
      template<typename T> const T& get(const ConditionKey& key_value)  const;
 
 
      template<typename T> T& get(Condition::key_type key_value);
 
 
      template<typename T> const T& get(Condition::key_type key_value)  const;
 
 
      bool registerOne(const IOV& iov, Condition cond);
      size_t registerMany(const IOV& iov, const std::vector<Condition>& values);
      template <typename CONT> size_t registerUnmapped(const IOV& iov_val, CONT& values)   {
        std::vector<Condition> conds;
        conds.reserve(values.size());
        std::copy(std::begin(values), std::end(values), std::back_inserter(conds));
        return this->registerMany(iov_val, conds);
      }
      template <typename CONT> size_t registerMapping(const IOV& iov_val, CONT& values)     {
        std::vector<Condition> conds;
        conds.reserve(values.size());
        std::transform(std::begin(values), std::end(values), std::back_inserter(conds), detail::get_2nd<CONT>());
        return this->registerMany(iov_val, conds);
      }
    };
 
 
    class ConditionUpdateCall  {
    protected:
      ConditionUpdateCall();
      ConditionUpdateCall(const ConditionUpdateCall& copy) = delete;
      virtual ~ConditionUpdateCall();
      ConditionUpdateCall& operator=(const ConditionUpdateCall& copy) = delete;
 
    public:
      virtual Condition operator()(const ConditionKey& target,
                                   ConditionUpdateContext& ctxt) = 0;
      virtual void resolve(Condition /* c */, ConditionUpdateContext& /* ctxt */)   {}
    };
 
 
    class ConditionDependency    {
      friend std::default_delete<ConditionDependency>;
    protected:
      int                                  m_refCount {0};
 
    public:
      DetElement                           detector;
      ConditionKey                         target {0};
      std::vector<ConditionKey>            dependencies;
      std::shared_ptr<ConditionUpdateCall> callback;
 
    protected:
      ConditionDependency(const ConditionDependency& c) = delete;
      ConditionDependency& operator=(const ConditionDependency& c) = delete;
      virtual ~ConditionDependency();
 
    public:
      ConditionDependency(DetElement de, const std::string& item, std::shared_ptr<ConditionUpdateCall> call);
      ConditionDependency(DetElement de, Condition::itemkey_type item_key, std::shared_ptr<ConditionUpdateCall> call);
      ConditionDependency();
      Condition::key_type key()  const    {  return target.hash;                   }
#if defined(DD4HEP_CONDITIONS_HAVE_NAME)
      const char* name()  const           {  return target.name.c_str();           }
#endif
      ConditionDependency* addRef()       {  ++m_refCount; return this;            }
      void release()                      {  if ( --m_refCount <= 0 ) delete this; }
    };
 
 
    class DependencyBuilder  {
    protected:
      std::unique_ptr<ConditionDependency> m_dependency;
    public:
      DependencyBuilder(DetElement de, Condition::itemkey_type item_key, std::shared_ptr<ConditionUpdateCall> call);
      DependencyBuilder(DetElement de, const std::string& item, std::shared_ptr<ConditionUpdateCall> call);
      virtual ~DependencyBuilder();
      ConditionDependency* operator->()  {   return m_dependency.operator->(); }
      void add(const ConditionKey& source_key);
      ConditionDependency* release();
    };
 
    inline ConditionUpdateContext::ConditionUpdateContext(ConditionResolver* resolv,
                                                          const ConditionDependency* dep,
                                                          IOV* i,
                                                          ConditionUpdateUserContext* user_param)
      : resolver(resolv), dependency(dep), iov(i), parameter(user_param)
    {
    }
 
    inline const ConditionKey&
    ConditionUpdateContext::key(size_t which)  const  {
      return dependency->dependencies.at(which);
    }
 
    template<typename T> inline T&
    ConditionUpdateContext::get(const ConditionKey& key_value)   {
      Condition cond = condition(key_value);
      if ( cond.isValid() )  {
        return cond.get<T>();       
      }
      accessFailure(key_value);
      throw std::runtime_error("ConditionUpdateCall");
    }
 
    template<typename T> inline const T&
    ConditionUpdateContext::get(const ConditionKey& key_value)  const  {
      Condition cond = condition(key_value);
      if ( cond.isValid() )  {
        return cond.get<T>();       
      }
      accessFailure(key_value);
      throw std::runtime_error("ConditionUpdateCall");
    }
 
    template<typename T> inline T&
    ConditionUpdateContext::get(Condition::key_type key_value)    {
      return condition(key_value).get<T>();
    }
 
    template<typename T> inline const T&
    ConditionUpdateContext::get(Condition::key_type key_value)  const   {
      return condition(key_value).get<T>();
    }
 
  }       /* End namespace cond               */
}         /* End namespace dd4hep                   */
#endif // DD4HEP_CONDITIONDERIVED_H