ConditionsManagerObject.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_CONDITIONSMANAGEROBJECT_H
#define DDCOND_CONDITIONSMANAGEROBJECT_H
 
// Framework include files
#include "DD4hep/Conditions.h"
#include "DD4hep/NamedObject.h"
#include "DDCond/ConditionsPool.h"
#include "DDCond/ConditionsSlice.h"
#include "DDCond/ConditionsDataLoader.h"
 
// C/C++ include files
#include <memory>
#include <vector>
#include <set>
 
namespace dd4hep {
 
  // Forward declarations
  class IOVType;
 
  namespace cond {
 
    // Forward declarations
    class ConditionsIOVPool;
    class ConditionsListener;
    
 
    class ConditionsManagerObject : public NamedObject,
                                    public PropertyConfigurable
    {
    public:
      typedef Condition::key_type                   key_type;
      typedef std::pair<ConditionsListener*,void*>  Listener;
      typedef std::set<Listener>                    Listeners;
      typedef std::unique_ptr<ConditionsDataLoader> Loader;
      typedef ConditionsManager::Result             Result;
 
    protected:
      Detector&              m_detDesc;
      Listeners              m_onRegister;
      Listeners              m_onRemove;
      Loader                 m_loader;
      bool                   m_doLoad = true;
      bool                   m_doOutputUnloaded = false;
 
      void registerCallee(Listeners& listeners, const Listener& callee, bool add);
 
    public:
 
      ConditionsManagerObject(Detector& description);
 
      virtual ~ConditionsManagerObject();
 
      Detector& detectorDescription() const {  return m_detDesc;              }
 
      ConditionsDataLoader* loader()  const {  return m_loader.get();         }
 
      bool doLoadConditions()  const        {  return m_doLoad;               }
 
      bool doOutputUnloaded()  const        {  return m_doOutputUnloaded;     }
 
      void onRegister(Condition condition);
 
      void onRemove(Condition condition);
 
      void callOnRegister(const Listener& callee, bool add);
 
      void callOnRemove(const Listener& callee, bool add);
 
      const std::vector<const IOVType*> iovTypesUsed() const;
 
      void fromString(const std::string& iov_str, IOV& iov);
 
      ConditionsPool* registerIOV(const std::string& data);
 
      virtual void initialize() = 0;
 
      virtual const std::vector<IOVType>& iovTypes () const = 0;
 
      virtual const IOVType* iovType (size_t iov_type) const = 0;
 
      virtual const IOVType* iovType (const std::string& iov_name) const = 0;
 
 
      virtual std::pair<bool, const IOVType*> registerIOVType(size_t iov_type, const std::string& iov_name) = 0;
 
      virtual ConditionsPool* registerIOV(const IOVType& typ, IOV::Key key) = 0;
      
      virtual ConditionsIOVPool* iovPool(const IOVType& type)  const = 0;
#if 0
      virtual Condition get(key_type key, const IOV& req_validity) = 0;
 
      virtual RangeConditions getRange(key_type key, const IOV& req_validity) = 0;
#endif
 
      virtual void pushUpdates() = 0;
 
      virtual bool registerUnlocked(ConditionsPool& pool, Condition cond) = 0;
 
      virtual size_t blockRegister(ConditionsPool& pool, const std::vector<Condition>& cond) const = 0;
 
      virtual std::unique_ptr<UserPool> createUserPool(const IOVType* iovT) const = 0;
 
      virtual Result prepare(const IOV& req_iov, ConditionsSlice& slice, ConditionUpdateUserContext* ctx=0) = 0;
 
      virtual Result load(const IOV&                  required_validity,
                          ConditionsSlice&            slice,
                          ConditionUpdateUserContext* ctxt=0) = 0;
 
      virtual Result compute(const IOV&                  required_validity,
                             ConditionsSlice&            slice,
                             ConditionUpdateUserContext* ctxt=0) = 0;
 
 
      virtual void adoptCleanup(ConditionsCleanup* cleaner) = 0;
 
 
      virtual int clean(const IOVType* typ, int max_age) = 0;
 
      virtual std::pair<int,int> clean(const ConditionsCleanup& cleaner)  = 0;
 
 
      virtual std::pair<int,int> clear() = 0;
 
    };
  }    /* End namespace detail                       */
}      /* End namespace dd4hep                         */
#endif // DDCOND_CONDITIONSMANAGEROBJECT_H