ConditionsPool.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_CONDITIONSPOOL_H
#define DDCOND_CONDITIONSPOOL_H
 
// Framework include files
#include "DD4hep/NamedObject.h"
#include "DD4hep/ConditionsMap.h"
#include "DDCond/ConditionsManager.h"
 
// C/C++ include files
 
namespace dd4hep {
 
  namespace cond {
 
    // Forward declarations
    class ConditionsSlice;
    class ConditionsIOVPool;
    class ConditionDependency;
    
 
    class ConditionsPool : public NamedObject {
    protected:
      ConditionsManager m_manager;
      
    public:
      enum { AGE_NONE    = 0, 
             AGE_ANY     = 9999999,
             AGE_EXPIRED = 12345678
      };
      IOV* iov;
      int  age_value;
 
    public:
      void onRegister(Condition condition);
      void onRemove(Condition condition);
 
    public:
      ConditionsPool(ConditionsManager mgr, IOV* iov);
      virtual ~ConditionsPool();
      void print()   const;
      void print(const std::string& opt)   const;
      virtual size_t size()  const = 0;
      virtual void clear() = 0;
      virtual bool insert(Condition cond) = 0;
      virtual void insert(RangeConditions& cond) = 0;
      virtual Condition exists(Condition::key_type key)  const = 0;
      virtual size_t select(Condition::key_type key, RangeConditions& result) = 0;
      virtual size_t select_all(RangeConditions& result) = 0;
      virtual size_t select_all(const ConditionsSelect& predicate) = 0;
      virtual size_t select_all(ConditionsPool& selection_pool) = 0;
    };
 
 
    class UpdatePool : public ConditionsPool  {
 
    public:
      typedef std::vector<Condition> ConditionEntries;
      typedef std::map<const IOV*, ConditionEntries> UpdateEntries;
 
    public:
      UpdatePool(ConditionsManager mgr, IOV* iov);
      virtual ~UpdatePool();
      virtual size_t popEntries(UpdateEntries& entries) = 0;
      virtual void select_range(Condition::key_type key, 
                                const IOV& req_validity,
                                RangeConditions& result) = 0;
    };
 
 
    class UserPool : public ConditionsMap {
    public:
      typedef std::map<Condition::key_type,const ConditionDependency*> Dependencies;
 
    protected:
      IOV                 m_iov;
      ConditionsManager   m_manager;
 
    public:
      enum {
        PRINT_NONE   = 0,
        PRINT_INSERT = 1<<0,
        PRINT_CLEAR  = 1<<1,
    PRINT_LOAD   = 1<<2,
        PRINT_COMPUTE= 1<<3,
    PRINT_LAST
      };
      unsigned int flags = 0;
 
      virtual bool insert(Condition condition) = 0;
 
    public:
      UserPool(ConditionsManager mgr);
      virtual ~UserPool();
      const IOV& validity() const    {  return m_iov;  }
      const IOV* validityPtr() const {  return &m_iov; }
      virtual void print(const std::string& opt) const = 0;
      virtual size_t size()  const = 0;
      virtual void clear() = 0;
      virtual bool exists(Condition::key_type key)  const = 0;
      virtual bool exists(const ConditionKey& key)  const = 0;
      virtual Condition get(Condition::key_type key)  const = 0;
      virtual Condition get(const ConditionKey& key)  const = 0;
      virtual bool remove(Condition::key_type hash_key) = 0;
      virtual bool remove(const ConditionKey& 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);
      }
      virtual bool insert(DetElement detector, Condition::itemkey_type key, Condition condition) = 0;
 
      virtual Condition get(DetElement detector, Condition::itemkey_type key)  const = 0;
      virtual std::vector<Condition> get(Condition::key_type lower,
                                         Condition::key_type upper)  const = 0;
      virtual std::vector<Condition> get(DetElement detector,
                                         Condition::itemkey_type lower,
                                         Condition::itemkey_type upper)  const = 0;
 
      virtual void scan(const Condition::Processor& processor) const = 0;
      virtual void scan(Condition::key_type lower,
                        Condition::key_type upper,
                        const Condition::Processor& processor) const = 0;
      virtual void scan(DetElement detector,
                        Condition::itemkey_type lower,
                        Condition::itemkey_type upper,
                        const Condition::Processor& processor) const = 0;
 
      virtual ConditionsManager::Result prepare(const IOV&                  required, 
                                                ConditionsSlice&            slice,
                                                ConditionUpdateUserContext* user_param = 0) = 0;
 
      virtual ConditionsManager::Result load(const IOV&                  required_validity,
                                             ConditionsSlice&            slice,
                                             ConditionUpdateUserContext* ctxt=0)  = 0;
      virtual ConditionsManager::Result compute(const IOV&                  required_validity,
                                                ConditionsSlice&            slice,
                                                ConditionUpdateUserContext* ctxt=0)  = 0;
      
      virtual size_t compute(const Dependencies& dependencies,
                             ConditionUpdateUserContext* user_param,
                             bool force) = 0;
    };
  }        /* End namespace cond                     */
}          /* End namespace dd4hep                   */
#endif // DDCOND_CONDITIONSPOOL_H