ConditionsProcessor.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 DD4HEP_CONDITIONSPROCESSOR_H
#define DD4HEP_CONDITIONSPROCESSOR_H
 
// Framework include files
#include <DD4hep/DetElement.h>
#include <DD4hep/Conditions.h>
#include <DD4hep/ConditionsMap.h>
 
// C/C++ include files
#include <memory>
 
namespace dd4hep {
 
  namespace cond   {
 
 
 
    template <typename T> class ConditionsProcessor : public Condition::Processor  {
      T& processor;
    public:
      ConditionsProcessor() = delete;
      ConditionsProcessor(T& p) : processor(p) {}
      ConditionsProcessor(T&& p) = delete;
      ConditionsProcessor(ConditionsProcessor&& copy) = default;
      ConditionsProcessor(const ConditionsProcessor& copy) = default;
      virtual ~ConditionsProcessor() = default;
      ConditionsProcessor& operator=(const ConditionsProcessor& copy) = default;
      virtual int process(Condition condition)  const override  {
        return (processor)(condition);
      }
    };
    template <typename T> inline
    ConditionsProcessor<typename std::remove_reference<T>::type> conditionsProcessor(T&& obj)
    { return ConditionsProcessor<typename std::remove_reference<T>::type>(obj);   }
 
 
    template <typename T> class ConditionsProcessorWrapper : public Condition::Processor  {
      std::unique_ptr<T> processor;
    public:
      ConditionsProcessorWrapper() = default;
      ConditionsProcessorWrapper(T* p) : processor(p) {}
      ConditionsProcessorWrapper(const ConditionsProcessorWrapper& copy) = delete;
      virtual ~ConditionsProcessorWrapper() = default;
      ConditionsProcessorWrapper& operator=(const ConditionsProcessorWrapper& copy) = delete;
      virtual int process(Condition c)  const override  {
        return (*(processor.get()))(c);
      }
    };
    template <typename T> inline ConditionsProcessorWrapper<T>* createProcessorWrapper(T* obj)  {
      return new ConditionsProcessorWrapper<T>(obj);
    }
    template <typename T> inline ConditionsProcessorWrapper<T> processorWrapper(T* obj)  {
      return ConditionsProcessorWrapper<T>(obj);
    }
 
 
    template <typename T> class ConditionsCollector  {
    public:
      ConditionsMap& mapping;
      T&             conditions;
    public:
      ConditionsCollector(ConditionsMap& m, T& d) : mapping(m), conditions(d) {}
      ConditionsCollector(ConditionsMap& m, T&& p) = delete;
      ConditionsCollector(ConditionsCollector&& copy) = default;
      ConditionsCollector(const ConditionsCollector& copy) = default;
      ~ConditionsCollector() = default;
      ConditionsCollector& operator=(const ConditionsCollector& copy) = default;
 
      virtual int operator()(DetElement de, int level=0)  const final;
    };
    template <typename T> inline
    ConditionsCollector<typename std::remove_reference<T>::type> conditionsCollector(ConditionsMap& m, T&& conditions)
    {  return ConditionsCollector<typename std::remove_reference<T>::type>(m, conditions); }
    
 
  }       /* End namespace cond               */
}         /* End namespace dd4hep                   */
#endif // DD4HEP_CONDITIONSPROCESSOR_H