ConditionsManager.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_CONDITIONSMANAGER_H
#define DDCOND_CONDITIONSMANAGER_H
 
// Framework include files
#include "DD4hep/Conditions.h"
#include "DD4hep/ComponentProperties.h"
 
// C/C++ include files
#include <set>
#include <memory>
 
namespace dd4hep {
 
  namespace cond {
 
    // Forward declarations
    class UserPool;
    class ConditionsPool;
    class ConditionsSlice;
    class ConditionsCleanup;
    class ConditionsIOVPool;
    class ConditionsDataLoader;
    class ConditionsManagerObject;
    class ConditionUpdateUserContext;
    
 
    class ConditionsManager : public Handle<ConditionsManagerObject> {
    public:
 
      typedef ConditionsManagerObject  Object;
      typedef std::vector<IOVType>     IOVTypes;
 
 
      class Result  {
      public:
        size_t selected = 0;
        size_t loaded   = 0;
        size_t computed = 0;
        size_t missing  = 0;
        Result() = default;
        Result(const Result& result) = default;
        Result& operator=(const Result& result) = default;
        size_t total() const { return selected+computed+loaded; }
        Result& operator +=(const Result& result);
        Result& operator -=(const Result& result);
      };
 
    public:
 
 
      template <typename T> static ConditionsManager from(T& host);
 
      ConditionsManager(Detector& description);
 
      ConditionsManager(Detector& description, const std::string& factory);
 
      ConditionsManager() = default;
 
      ConditionsManager(Object* p) : Handle<Object>(p) {}
 
      ConditionsManager(const ConditionsManager& c) = default;
 
      template <typename Q> ConditionsManager(const Handle<Q>& e) : Handle<Object>(e) {}
 
      ~ConditionsManager() = default;
 
      ConditionsManager& operator=(const ConditionsManager& c) = default;
      
      ConditionsManager& initialize();
 
      Detector& detectorDescription()  const;
      
      Property& operator[](const std::string& property_name) const;
 
      PropertyManager& properties()  const;
 
      ConditionsDataLoader& loader()  const;
 
      const std::vector<const IOVType*> iovTypesUsed() const;
 
      const IOVType* iovType (const std::string& iov_name) const;
 
      ConditionsIOVPool* iovPool(const IOVType& type)  const;
 
      void fromString(const std::string& iov_str, IOV& iov)  const;
 
 
      std::pair<bool, const IOVType*> registerIOVType(size_t iov_type, const std::string& iov_name) const;
 
      ConditionsPool* registerIOV(const IOV& iov) const;
 
      ConditionsPool* registerIOV(const IOVType& typ, IOV::Key key) const;
 
      ConditionsPool* registerIOV(const std::string& iov_rep)  const;
 
      bool registerUnlocked(ConditionsPool& pool, Condition cond) const;
 
      size_t blockRegister(ConditionsPool& pool, const std::vector<Condition>& cond) const;
      
 
      void pushUpdates() const;
 
 
      void adoptCleanup(ConditionsCleanup* cleaner)  const;
      
      void clean(const ConditionsCleanup& cleaner)  const;
 
      void clean(const IOVType* typ, int max_age) const;
 
      void clear()  const;
      
      std::unique_ptr<UserPool> createUserPool(const IOVType* iovT)  const;
 
      Result prepare(const IOV&                  required_validity,
                     ConditionsSlice&            slice,
                     ConditionUpdateUserContext* ctxt=0)  const;
      Result load(const IOV&                  required_validity,
                  ConditionsSlice&            slice,
                  ConditionUpdateUserContext* ctxt=0)  const;
      Result compute(const IOV&                  required_validity,
                     ConditionsSlice&            slice,
                     ConditionUpdateUserContext* ctxt=0)  const;
    };
    
    inline ConditionsManager::Result&
    ConditionsManager::Result::operator +=(const Result& result)  {
      selected += result.selected;
      loaded   += result.loaded;
      computed += result.computed;
      missing  += result.missing;
      return *this;
    }
    inline ConditionsManager::Result&
    ConditionsManager::Result::operator -=(const Result& result)  {
      selected -= result.selected;
      loaded   -= result.loaded;
      computed -= result.computed;
      missing  -= result.missing;
      return *this;
    }
  }       /* End namespace cond        */
}         /* End namespace dd4hep            */
#endif // DDCOND_CONDITIONSMANAGER_H