Manager_Type1.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_TYPE1_MANAGER_TYPE1_H
#define DDCOND_TYPE1_MANAGER_TYPE1_H
 
// Framework include files%
#include "DD4hep/Mutex.h"
#include "DD4hep/ObjectExtensions.h"
#include "DDCond/ConditionsManagerObject.h"
 
// C/C++ include files
#include <memory>
 
namespace dd4hep {
 
  namespace cond {
 
    class Entry;
    class ConditionsPool;
    class ConditionsSlice;
    class ConditionsIOVPool;
    class ConditionsDataLoader;
 
 
    class Manager_Type1 : public ConditionsManagerObject, 
                          public ObjectExtensions
    {
    public:
      typedef std::vector<ConditionsIOVPool*> TypedConditionPool;
 
    protected:
 
      int                     m_maxIOVTypes;
      std::string             m_poolType;
      std::string             m_updateType;
      std::string             m_userType;
      std::string             m_loaderType;
 
      std::vector<IOVType>    m_iovTypes;
 
      dd4hep_mutex_t          m_updateLock;
      dd4hep_mutex_t          m_poolLock;
      std::unique_ptr<UpdatePool>  m_updatePool;
      std::unique_ptr<ConditionsCleanup> m_cleaner;
      
    public:
      TypedConditionPool      m_rawPool;
      int                     m_locked;
 
    protected:
      bool select(key_type key, const IOV& req_validity, RangeConditions& conditions);
 
      bool select_range(key_type key, const IOV& req_validity, RangeConditions& conditions);
 
      // void __register_immediate(RangeConditions& c);
 
 
      void __get_checked_pool(const IOV& required_validity, std::unique_ptr<UserPool>& user_pool);
      
      Condition __queue_update(cond::Entry* data);
 
    public:
      Manager_Type1(Detector& description);
 
      virtual ~Manager_Type1();
 
      //const TypedConditionPool& conditionsPool() const  {  return m_rawPool; }
      
      void initialize();
 
 
      virtual std::pair<bool, const IOVType*> registerIOVType(size_t iov_index, const std::string& iov_name) final;
      
      virtual const std::vector<IOVType>& iovTypes () const final { return  m_iovTypes;  }
 
      virtual const IOVType* iovType (size_t iov_index) const final;
 
      virtual const IOVType* iovType (const std::string& iov_name) const final;
 
      virtual ConditionsPool* registerIOV(const IOVType& typ, IOV::Key key)  final;
 
      virtual ConditionsIOVPool* iovPool(const IOVType& type)  const  final;
 
      virtual bool registerUnlocked(ConditionsPool& pool, Condition cond)  final;
 
      virtual size_t blockRegister(ConditionsPool& pool, const std::vector<Condition>& cond) const final;
 
      virtual void adoptCleanup(ConditionsCleanup* cleaner)  final;
      
 
      virtual int clean(const IOVType* typ, int max_age)  final;
 
 
      virtual std::pair<int,int> clean(const ConditionsCleanup& cleaner)  final;
 
 
      virtual std::pair<int,int> clear()  final;
 
 
      virtual void pushUpdates()  final;
#if 0 
      virtual Condition get(key_type key, const IOV& req_validity)  final;
 
      virtual RangeConditions getRange(key_type key, const IOV& req_validity)  final;
#endif
      virtual std::unique_ptr<UserPool> createUserPool(const IOVType* iovT)  const;
 
 
      virtual Result prepare(const IOV& req_iov, ConditionsSlice& slice, ConditionUpdateUserContext* ctxt)  final;
 
      virtual Result load(const IOV&                  required_validity,
                          ConditionsSlice&            slice,
                          ConditionUpdateUserContext* ctxt=0) final;
      virtual Result compute(const IOV&                  required_validity,
                             ConditionsSlice&            slice,
                             ConditionUpdateUserContext* ctxt=0) final;
 
 
    };
  }        /* End namespace cond               */
}          /* End namespace dd4hep                   */
#endif // DDCOND_TYPE1_MANAGER_TYPE1_H