DetectorProcessor.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_DETECTORPROCESSOR_H
#define DD4HEP_DETECTORPROCESSOR_H
 
// Framework includes
#include <DD4hep/DetElement.h>
 
// C/C++ include files
#include <memory>
 
namespace dd4hep {
 
 
  class DetectorProcessor {
  public:
    DetectorProcessor() = default;
    DetectorProcessor(DetectorProcessor&& copy) = default;
    DetectorProcessor(const DetectorProcessor& copy) = default;
    virtual ~DetectorProcessor();
    DetectorProcessor& operator=(const DetectorProcessor& copy) = default;
    virtual int operator()(DetElement de, int level)  const = 0;
    virtual int process(DetElement de, int level, bool recursive)  const;
  };
 
 
  template <typename T> class DetElementProcessor : virtual public DetectorProcessor  {
  public:
    T& processor;
  public:
    DetElementProcessor() = delete;
    DetElementProcessor(T& p) : processor(p) {}
    DetElementProcessor(T&& p) = delete;
    DetElementProcessor(DetElementProcessor&& copy) = default;
    DetElementProcessor(const DetElementProcessor& copy) = default;
    virtual ~DetElementProcessor() = default;
    DetElementProcessor& operator=(const DetElementProcessor& copy) = default;
    virtual int operator()(DetElement de, int level)  const final
    {   return (processor)(de, level);         }
  };
 
  template <typename T> inline
  DetElementProcessor<typename std::remove_reference<T>::type> detectorProcessor(T&& proc)
  { return DetElementProcessor<typename std::remove_reference<T>::type>(std::forward<T>(proc)); }
 
 
  template <typename T> class DetectorProcessorShared : public DetectorProcessor {
  public:
    std::shared_ptr<T> processor;
  public:
    DetectorProcessorShared() = delete;
    DetectorProcessorShared(std::shared_ptr<T>& p) : processor(p) {}
    DetectorProcessorShared(const DetectorProcessorShared& copy) = default;
    virtual ~DetectorProcessorShared() = default;
    DetectorProcessorShared& operator=(const DetectorProcessorShared& copy) = default;
    virtual int operator()(DetElement de, int level)  const final
    {  return (*processor)(de, level);                 }
  };
 
 
  template <typename T> class DetElementsCollector  {
  public:
    T&             elements;
  public:
    DetElementsCollector(T& d) : elements(d) {}
    DetElementsCollector(T&& p) = delete;
    DetElementsCollector(DetElementsCollector&& copy) = default;
    DetElementsCollector(const DetElementsCollector& copy) = default;
    ~DetElementsCollector() = default;
    DetElementsCollector& operator=(const DetElementsCollector& copy) = default;
 
    virtual int operator()(DetElement de, int level)  const final;
  };
  
  template <typename T> inline
  DetElementsCollector<typename std::remove_reference<T>::type> detElementsCollector(T&& container)
  {  return DetElementsCollector<typename std::remove_reference<T>::type>(container); }
 
 
  class DetectorScanner  {
  public:
    DetectorScanner() = default;
    DetectorScanner(const DetectorScanner& copy) = default;
    DetectorScanner& operator=(const DetectorScanner& copy) = default;
 
    template <typename Q>
    DetectorScanner(Q& proc, DetElement start, int level=0, bool recursive=true)
    {  scan(proc, start, level, recursive);     }
 
    template <typename Q>
    DetectorScanner(const Q& proc, DetElement start, int level=0, bool recursive=true)
    {  scan(proc, start, level, recursive);     }
 
    template <typename Q>
    int scan(Q& p, DetElement start, int level=0, bool recursive=true)  const {
      auto proc = detectorProcessor(p);
      return proc.process(start, level, recursive);
    }
 
    template <typename Q>
    int scan(const Q& p, DetElement start, int level=0, bool recursive=true) const {
      auto proc = detectorProcessor(p);
      return proc.process(start, level, recursive);
    }
  };
}      /* End namespace dd4hep               */
#endif // DD4HEP_DETECTORPROCESSOR_H