ConditionsDependencyHandler.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 DDCOND_CONDITIONSDEPENDENCYHANDLER_H
#define DDCOND_CONDITIONSDEPENDENCYHANDLER_H
 
// Framework include files
#include "DD4hep/DetElement.h"
#include "DD4hep/ConditionDerived.h"
#include "DDCond/ConditionsPool.h"
#include "DDCond/ConditionsManager.h"
 
namespace dd4hep {
 
  namespace cond {
 
    // Forward declarations
    class UserPool;
    class ConditionsPool;
    class ConditionsManagerObject;
    
 
    class ConditionsDependencyHandler : public ConditionResolver {
    public:
      enum State  {  INVALID, CREATED, RESOLVED };
      struct Work  {
      public:
        IOV                        _iov;
        ConditionUpdateContext     context;
        IOV*                       iov       = 0;
        Condition::Object*         condition = 0;
        int                        callstack = 0;
        State                      state     = INVALID;
      public:
        Work() = delete;
        Work(ConditionResolver* r,
             const ConditionDependency* d,
             ConditionUpdateUserContext* u,
             const IOV& i)
          : _iov(i), context(r,d,&_iov,u) {}
        Work(const Work&) = default;
        Work& operator=(const Work&) = default;
        void do_intersection(const IOV* iov);
        Condition resolve(Work*& current);
      };
      typedef std::map<Condition::key_type, const ConditionDependency*>  Dependencies;
      typedef std::map<Condition::key_type, Work*> WorkConditions;
 
    protected:
      ConditionsManagerObject*    m_manager;
      UserPool&                   m_pool;
      const Dependencies&         m_dependencies;
      ConditionUpdateUserContext* m_userParam;
      const IOVType*              m_iovType = 0;
      WorkConditions              m_todo;
      State                       m_state = CREATED;
      Work*                       m_block = 0;
      Work*                       m_currentWork = 0;
    public:
      mutable size_t              num_callback;
 
    protected:
      void do_callback(Work* dep);
 
    public:
      ConditionsDependencyHandler(ConditionsManager mgr,
                                  UserPool& pool, 
                                  const Dependencies& dependencies,
                                  ConditionUpdateUserContext* user_param);
      ~ConditionsDependencyHandler();
 
      //const CreatedConditions& created()  const                  { return m_created;         }
      void compute();
      void resolve();
 
      virtual Detector& detectorDescription() const  override;
      virtual Ref_t manager() const  override                 { return m_manager;           }
      virtual const IOV& requiredValidity()  const  override  { return m_pool.validity();   }
      virtual ConditionsMap& conditionsMap() const override   { return m_pool;              }
      virtual Condition get(const ConditionKey& key) override
      {  return get(key.hash, nullptr, true);                                               }
      virtual Condition get(const ConditionKey& key, bool throw_if_not)  override
      {  return get(key.hash, nullptr, throw_if_not);                                       }
      virtual Condition get(Condition::key_type key) override
      {  return get(key, nullptr, true);                                                    }
      virtual Condition get(Condition::key_type key, bool throw_if_not)  override;
      virtual Condition get(Condition::key_type key,
                            const ConditionDependency* dependency,
                            bool throw_if_not)  override;
      virtual std::vector<Condition> get(DetElement de)    override;
      virtual std::vector<Condition> get(Condition::detkey_type key)   override;
      virtual std::vector<Condition> getByItem(Condition::itemkey_type key)   override;
      virtual bool registerOne(const IOV& iov, Condition cond)   override;
      virtual size_t registerMany(const IOV& iov, const std::vector<Condition>& values)   override;
    };
 
  }        /* End namespace cond                */
}          /* End namespace dd4hep                    */
 
#endif // DDCOND_CONDITIONSDEPENDENCYHANDLER_H