ConditionsSlice.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_CONDITIONSSLICE_H
#define DDCOND_CONDITIONSSLICE_H
 
// Framework include files
#include "DD4hep/Conditions.h"
#include "DD4hep/ConditionsMap.h"
#include "DD4hep/ConditionDerived.h"
 
#include "DDCond/ConditionsPool.h"
#include "DDCond/ConditionsContent.h"
#include "DDCond/ConditionsManager.h"
 
// C/C++ include files
#include <memory>
 
namespace dd4hep {
 
  namespace cond {
 
    // Forward declarations
    class UserPool;
    class ConditionsSlice;
    
 
    class ConditionsSlice : public ConditionsMap  {
    public:
      typedef Condition::key_type                           key_type;
      typedef std::vector<std::shared_ptr<ConditionsPool> > ContainedPools;
 
      enum ManageFlag {
        REGISTER_MANAGER= 1<<0,
        REGISTER_POOL   = 1<<1,
        REGISTER_FULL   = REGISTER_MANAGER|REGISTER_POOL
      };
      enum LoadFlags  {
        REF_POOLS       = 1<<1
      };
      
 
      class Inserter  {
        ConditionsSlice& slice;
        ConditionsPool*  iov_pool = 0;
 
      public:
        Inserter(ConditionsSlice& s) : slice(s) {
          const IOV& iov = s.pool->validity();
          iov_pool = s.manager.registerIOV(*iov.iovType,iov.key());
        }
        template <typename T> Inserter(ConditionsSlice& s, const T& data) : slice(s) {
          const IOV& iov = slice.pool->validity();
          iov_pool = slice.manager.registerIOV(*iov.iovType,iov.key());
          std::for_each(std::begin(data), std::end(data), *this);
        }
        void operator()(Condition c) const  {
          slice.manager.registerUnlocked(*iov_pool,c);
          slice.pool->insert(c);
        }
        void operator()(const std::pair<Condition::key_type,Condition>& e) const  {
          (*this)(e.second);
        }
        template <typename T> void process(const T& data)  const   {
          std::for_each(std::begin(data), std::end(data), *this);
        }
      };
 
    public:
 
      ConditionsManager         manager;
      std::unique_ptr<UserPool> pool;
      std::shared_ptr<ConditionsContent> content;
 
      ConditionsManager::Result status;
      ContainedPools            used_pools;
      unsigned long             flags = 0;
      
    protected:
      ConditionsContent::Conditions   m_missingConditions;
      ConditionsContent::Dependencies m_missingDerivations;
      
      ConditionsSlice& operator=(const ConditionsSlice& copy) = delete;
 
 
      virtual bool manage(ConditionsPool* pool, Condition condition, ManageFlag flg);
 
      static Condition select_cond(Condition c)  {  return c; }
      template <typename T>
      static Condition select_cond(const std::pair<T,Condition>& c)  {  return c.second; }
    public:
      ConditionsSlice() = delete;
      ConditionsSlice(ConditionsManager m);
      ConditionsSlice(ConditionsManager m, const std::shared_ptr<ConditionsContent>& c);
      ConditionsSlice(const ConditionsSlice& copy);
      virtual ~ConditionsSlice();
 
      size_t size() const   { return content->conditions().size()+content->derived().size(); }
      void refPools()       { this->flags |= REF_POOLS;                                      }
      void derefPools();
      const ConditionsContent::Conditions& conditions() const { return content->conditions();}
      const ConditionsContent::Dependencies& derived() const  { return content->derived();   }
      ConditionsContent::Conditions& missingConditions()      { return m_missingConditions;  }
      ConditionsContent::Dependencies& missingDerivations()   { return m_missingDerivations; }
      const IOV& iov()  const;
      void reset();
 
 
      template <typename T> void manage(const T& conds, ManageFlag flg)  {
        if ( !conds.empty() )  {
          ConditionsPool* p = (flg&REGISTER_MANAGER) ? manager.registerIOV(pool->validity()) : 0;
          for( const auto& e : conds )
            manage(p, select_cond(e), flg);
        }
      }
 
      virtual bool manage(Condition condition, ManageFlag flg);
 
      std::vector<Condition> get(DetElement detector)  const;
      
      virtual bool insert(DetElement detector, Condition::itemkey_type key, Condition condition)  override;
      virtual Condition get(DetElement detector, Condition::itemkey_type key)  const override;
      virtual std::vector<Condition> get(DetElement detector,
                                         Condition::itemkey_type lower,
                                         Condition::itemkey_type upper)  const  override;
      virtual void scan(const Condition::Processor& processor) const  override;
      virtual void scan(DetElement       detector,
                        Condition::itemkey_type     lower,
                        Condition::itemkey_type     upper,
                        const Condition::Processor& processor) const  override;
    };
 
    void fill_content(ConditionsManager mgr, ConditionsContent& content, const IOVType& typ);
 
  }        /* End namespace cond               */
}          /* End namespace dd4hep                   */
#endif // DDCOND_CONDITIONSSLICE_H