ConditionDerived.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_GEOMETRY_CONDITIONDERIVED_H
#define DD4HEP_GEOMETRY_CONDITIONDERIVED_H

// Framework include files
#include "DD4hep/Memory.h"
#include "DD4hep/Conditions.h"
#include "DD4hep/objects/ConditionsInterna.h"

namespace DD4hep {

  class BasicGrammar;

  namespace Conditions   {

    class ConditionManager;
    class ConditionResolver;
    class ConditionDependency;
    class ConditionUpdateCall;


    class ConditionResolver   {
    public:
      virtual ~ConditionResolver();
      virtual Condition get(const ConditionKey& key) const = 0;
      virtual Condition get(unsigned int key) const = 0;
      virtual Ref_t manager() const = 0;
      virtual Geometry::LCDD& lcdd() const = 0;
      virtual const IOV& requiredValidity()  const = 0;
    };


    class ConditionUpdateContext  {
    public:
      const ConditionResolver&   resolver;
      const ConditionDependency& dependency;
      Condition::iov_type*       iov;
      void*                      parameter;
      ConditionUpdateContext(const ConditionResolver& r,
                             const ConditionDependency& d,
                             void* parameter,
                             Condition::iov_type& iov);
      const ConditionKey& key(size_t which)  const;
      Condition condition(size_t which)  const;
      Condition condition(const ConditionKey& key_value)  const;
      template<typename Q> Q* param()  const  {
        return static_cast<Q*>(parameter);
      }
      template<typename T> T& get(const ConditionKey& key_value)  {
        Condition cond = resolver.get(key_value);
        if ( cond.isValid() )  {
          T& data = cond.get<T>();          
          iov->iov_intersection(cond.iov());
          return data;
        }
        throw std::runtime_error("ConditionUpdateCall: Failed to access non-existing item:"+key_value.name);
      }
      template<typename T> const T& get(const ConditionKey& key_value)  const {
        Condition cond = resolver.get(key_value);
        if ( cond.isValid() )  {
          const T& data = cond.get<T>();  
          iov->iov_intersection(cond.iov());
          return data;
        }
        throw std::runtime_error("ConditionUpdateCall: Failed to access non-existing item:"+key_value.name);
      }
      template<typename T> T& get(size_t key_id)  {
        const ConditionKey& key_value = this->key(key_id);
        return this->get<T>(key_value);
      }
      template<typename T> const T& get(size_t key_id)  const {
        const ConditionKey& key_value = this->key(key_id);
        return this->get<T>(key_value);
      }
    };


    class ConditionUpdateCall  {
    public:
      typedef ConditionUpdateContext Context;
    protected:
      int  m_refCount;
      ConditionUpdateCall() : m_refCount(1)  {                      }
      virtual ~ConditionUpdateCall();

    public:
      ConditionUpdateCall* addRef()   {  ++m_refCount;  return this;  }
      void release()  {  if ( --m_refCount <= 0 ) delete this;        }
      virtual Condition operator()(const ConditionKey& target, const Context& ctxt) = 0;
    };


    class ConditionDependency    {
    protected:
      int                                m_refCount;

    public:
      typedef Geometry::DetElement       DetElement;
      typedef std::vector<ConditionKey>  Dependencies;
      typedef Condition::key_type        key_type;

      DetElement                         detector;
      ConditionKey                       target;
      Dependencies                       dependencies;
      ConditionUpdateCall*               callback;

    protected:
      ConditionDependency(const ConditionDependency& c);
      ConditionDependency& operator=(const ConditionDependency& c);
      virtual ~ConditionDependency();

    public:
      ConditionDependency(const ConditionKey& tar, const Dependencies deps, ConditionUpdateCall* call);
      ConditionDependency(const ConditionKey& tar, ConditionUpdateCall* call);
      ConditionDependency();
      key_type key()  const           {  return target.hash;         }
      ConditionDependency* addRef()   {  ++m_refCount; return this;  }
      void release()  {  if ( --m_refCount <= 0 ) delete this;       }
    };


    class DependencyBuilder  {
    protected:
      ConditionDependency* m_dependency;
    public:
      DependencyBuilder(const ConditionKey& target, ConditionUpdateCall* call);
      DependencyBuilder(const ConditionKey& target, ConditionUpdateCall* call, Geometry::DetElement de);
      virtual ~DependencyBuilder();
      ConditionDependency* operator->()            {   return m_dependency;   }
      void add(const ConditionKey& source);
      ConditionDependency* release();
    };

    inline ConditionUpdateContext::ConditionUpdateContext(const ConditionResolver& resolv,
                                                          const ConditionDependency& dep,
                                                          void* user_param,
                                                          Condition::iov_type& iov_ref)
      : resolver(resolv), dependency(dep), iov(&iov_ref), parameter(user_param)
    {
    }

    inline const ConditionKey& ConditionUpdateContext::key(size_t which)  const  {
      return dependency.dependencies[which];
    }

    inline Condition ConditionUpdateContext::condition(const ConditionKey& key_value)  const  {
      Condition c = resolver.get(key_value);
      if ( c.isValid() ) return c;
      throw std::runtime_error("ConditionUpdateCall: Failed to access non-existing condition:"+key_value.name);
    }

    inline Condition ConditionUpdateContext::condition(size_t which)  const   {
      const ConditionKey& key_value = this->key(which);
      return this->condition(key_value);
    }

  }       /* End namespace Conditions               */
}         /* End namespace DD4hep                   */
#endif    /* DD4HEP_GEOMETRY_CONDITIONDERIVED_H     */