ConditionsManager.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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/Memory.h"
#include "DD4hep/Detector.h"
#include "DD4hep/Conditions.h"
#include "DD4hep/ComponentProperties.h"
#include "DDCond/ConditionsDependencyCollection.h"

namespace DD4hep {

  namespace Conditions {

    // Forward declarations
    class Entry;
    class UserPool;
    class ConditionsPool;
    class ConditionsIOVPool;
    class ConditionDependency;
    class ConditionsDataLoader;
    class ConditionUpdateContext;
    class ConditionsManagerObject;
    

    class ConditionsManager : public Handle<ConditionsManagerObject> {
    public:

      typedef ConditionsManagerObject            Object;
      typedef ConditionsDataLoader               Loader;
      typedef std::vector<IOVType>               IOVTypes;
      typedef std::map<IOVType*,Container>       TypeConditions;
      typedef std::map<DetElement,Container>     DetectorConditions;
      typedef std::set<ConditionKey>             ConditionKeys;
      typedef ConditionDependency                Dependency;
      typedef ConditionsDependencyCollection     Dependencies;

    public:


      template <typename T> static ConditionsManager from(T& host);

      ConditionsManager(LCDD& lcdd);

      ConditionsManager() = default;

      ConditionsManager(Object* p) : Handle<Object>(p) {}

      ConditionsManager(const ConditionsManager& c) : Handle<Object>(c) {}

      template <typename Q> ConditionsManager(const Handle<Q>& e) : Handle<Object>(e) {}

      ~ConditionsManager() = default;

      ConditionsManager& operator=(const ConditionsManager& c) = default;
      
      ConditionsManager& initialize();

      Property& operator[](const std::string& property_name) const;

      PropertyManager& properties()  const;

      Handle<Loader> 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);


      std::pair<bool, const IOVType*> registerIOVType(size_t iov_type, const std::string& iov_name);

      ConditionsPool* registerIOV(const IOVType& typ, IOV::Key key);

      bool registerUnlocked(ConditionsPool* pool, Condition cond);

      void clean(const IOVType* typ, int max_age);

      void clear();

      long prepare(const IOV& required_validity,
                   const ConditionKeys& keys,
                   dd4hep_ptr<UserPool>& user_pool);

      long prepare(const IOV& required_validity,
                   const ConditionKeys&  keys,
                   dd4hep_ptr<UserPool>& user_pool,
                   const Dependencies&   dependencies,
                   bool                  verify_dependencies=true);

      long prepare(const IOV& required_validity, dd4hep_ptr<UserPool>& user_pool);

      long prepare(const IOV&            required_validity,
                   dd4hep_ptr<UserPool>& user_pool,
                   const Dependencies&   dependencies,
                   bool                  verify_dependencies=true);
    };

  }       /* End namespace Conditions               */
}         /* End namespace DD4hep                   */
#endif    /* DDCOND_CONDITIONSMANAGER_H             */