AlignmentsProcessor.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_ALIGNMENTSPROCESSOR_H
#define DD4HEP_ALIGNMENTSPROCESSOR_H
 
// Framework includes
#include <DD4hep/ConditionsMap.h>
#include <DD4hep/AlignmentData.h>
#include <DD4hep/Alignments.h>
#include <DD4hep/Printout.h>
 
// C/C++ include files
#include <memory>
 
namespace dd4hep {
 
  namespace align {
    
 
    template <typename T> class AlignmentsProcessor : public Alignment::Processor  {
      T& processor;
    public:
      AlignmentsProcessor() = default;
      AlignmentsProcessor(T& p) : processor(p) {}
      AlignmentsProcessor(T&& p) = delete;
      AlignmentsProcessor(AlignmentsProcessor&& copy) = default;
      AlignmentsProcessor(const AlignmentsProcessor& copy) = default;
      virtual ~AlignmentsProcessor() = default;
      AlignmentsProcessor& operator=(const AlignmentsProcessor& copy) = default;
      virtual int operator()(Alignment alignment)  const override  {
        return (processor)(alignment);
      }
    };
    template <typename T> inline
    AlignmentsProcessor<typename std::remove_reference<T>::type> alignmentsProcessor(T&& obj)
    {  return AlignmentsProcessor<typename std::remove_reference<T>::type>(obj);    }
 
 
    template <typename T> class AlignmentsProcessorWrapper : public Alignment::Processor  {
      std::unique_ptr<T> processor;
    public:
      AlignmentsProcessorWrapper() = default;
      AlignmentsProcessorWrapper(T* p) : processor(p) {}
      AlignmentsProcessorWrapper(const AlignmentsProcessorWrapper& copy) = default;
      virtual ~AlignmentsProcessorWrapper() = default;
      AlignmentsProcessorWrapper& operator=(const AlignmentsProcessorWrapper& copy) = default;
      virtual int operator()(Alignment c)  const override  {
        return (*(processor.get()))(c);
      }
    };
    template <typename T> inline AlignmentsProcessorWrapper<T>* createProcessorWrapper(T* obj)  {
      return new AlignmentsProcessorWrapper<T>(obj);
    }
    template <typename T> inline AlignmentsProcessorWrapper<T> processorWrapper(T* obj)  {
      return AlignmentsProcessorWrapper<T>(obj);
    }
 
 
    template <typename T> class DeltaCollector  {
    public:
      ConditionsMap& mapping;
      T&             deltas;
    public:
      DeltaCollector(ConditionsMap& m, T& d) : mapping(m), deltas(d) {}
      DeltaCollector(ConditionsMap& m, T&& p) = delete;
      DeltaCollector(DeltaCollector&& copy) = default;
      DeltaCollector(const DeltaCollector& copy) = default;
      ~DeltaCollector() = default;
      DeltaCollector& operator=(const DeltaCollector& copy) = default;
 
      virtual int operator()(DetElement de, int level=0)  const final;
    };
 
    template <typename T> inline
    DeltaCollector<typename std::remove_reference<T>::type> deltaCollector(ConditionsMap& m, T&& deltas)
    {    return DeltaCollector<typename std::remove_reference<T>::type>(m, deltas);    }
 
 
    template <typename T> class AlignmentsCollector  {
    public:
      ConditionsMap& mapping;
      T&             alignments;
    public:
      AlignmentsCollector(ConditionsMap& m, T& d) : mapping(m), alignments(d) {}
      AlignmentsCollector(ConditionsMap& m, T&& p) = delete;
      AlignmentsCollector(const AlignmentsCollector& copy) = default;
      ~AlignmentsCollector() = default;
      AlignmentsCollector& operator=(const AlignmentsCollector& copy) = default;
 
      virtual int operator()(DetElement de, int level=0)  const final;
    };
 
    template <typename T> inline
    AlignmentsCollector<typename std::remove_reference<T>::type> alignmentsCollector(ConditionsMap& m, T&& alignments)
    { return AlignmentsCollector<typename std::remove_reference<T>::type>(m, alignments); }
 
  }    /* End namespace align  */
}      /* End namespace dd4hep      */
#endif // DD4HEP_ALIGNMENTSPROCESSOR_H