VolumeProcessor.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_VOLUMEPROCESSOR_H
#define DD4HEP_VOLUMEPROCESSOR_H
 
// Framework includes
#include <DD4hep/DetElement.h>
#include <DD4hep/Volumes.h>
 
// C/C++ include files
#include <memory>
 
namespace dd4hep {
 
 
  class PlacedVolumeProcessor {
  public:
    PlacedVolumeProcessor() = default;
    PlacedVolumeProcessor(PlacedVolumeProcessor&& copy) = default;
    PlacedVolumeProcessor(const PlacedVolumeProcessor& copy) = default;
    virtual ~PlacedVolumeProcessor() noexcept(false);
    PlacedVolumeProcessor& operator=(const PlacedVolumeProcessor& copy) = default;
    virtual int operator()(PlacedVolume pv, int level) = 0;
    virtual int process(PlacedVolume pv, int level, bool recursive);
  };
 
 
  template <typename T> class PlacementProcessor : virtual public PlacedVolumeProcessor  {
  public:
    T& processor;
  public:
    PlacementProcessor() = delete;
    PlacementProcessor(T& p) : processor(p) {}
    PlacementProcessor(T&& p) = delete;
    PlacementProcessor(PlacementProcessor&& copy) = default;
    PlacementProcessor(const PlacementProcessor& copy) = default;
    virtual ~PlacementProcessor() = default;
    PlacementProcessor& operator=(const PlacementProcessor& copy) = default;
    virtual int operator()(PlacedVolume pv, int level)  final
    {   return (processor)(pv, level);         }
  };
 
  template <typename T> inline
  PlacementProcessor<typename std::remove_reference<T>::type> placementProcessor(T&& proc)
  { return PlacementProcessor<typename std::remove_reference<T>::type>(std::forward<T>(proc)); }
 
 
  template <typename T> class PlacementProcessorShared : public PlacedVolumeProcessor {
  public:
    std::shared_ptr<T> processor;
  public:
    PlacementProcessorShared() = delete;
    PlacementProcessorShared(std::shared_ptr<T>& p) : processor(p) {}
    PlacementProcessorShared(const PlacementProcessorShared& copy) = default;
    virtual ~PlacementProcessorShared() = default;
    PlacementProcessorShared& operator=(const PlacementProcessorShared& copy) = default;
    virtual int operator()(PlacedVolume pv, int level)  final
    {  return (*processor)(pv, level);                 }
  };
 
 
  class PlacedVolumeScanner  {
  public:
    PlacedVolumeScanner() = default;
    PlacedVolumeScanner(const PlacedVolumeScanner& copy) = default;
    PlacedVolumeScanner& operator=(const PlacedVolumeScanner& copy) = default;
 
    template <typename Q>
    PlacedVolumeScanner(Q& proc, DetElement start, int level=0, bool recursive=true)
    {  scan(proc, start.placement(), level, recursive);     }
 
    template <typename Q>
    PlacedVolumeScanner(const Q& proc, DetElement start, int level=0, bool recursive=true)
    {  scan(proc, start.placement(), level, recursive);     }
 
    template <typename Q>
    PlacedVolumeScanner(Q& proc, PlacedVolume start, int level=0, bool recursive=true)
    {  scan(proc, start, level, recursive);     }
 
    template <typename Q>
    PlacedVolumeScanner(const Q& proc, PlacedVolume start, int level=0, bool recursive=true)
    {  scan(proc, start, level, recursive);     }
 
    int scanPlacements(PlacedVolumeProcessor& proc, PlacedVolume start, int level=0, bool recursive=true)  const {
      return proc.process(start, level, recursive);
    }
    template <typename Q>
    int scan(Q& p, PlacedVolume start, int level=0, bool recursive=true)  const {
      auto proc = placementProcessor(p);
      return proc.process(start, level, recursive);
    }
    template <typename Q>
    int scan(const Q& p, PlacedVolume start, int level=0, bool recursive=true) const {
      auto proc = placementProcessor(p);
      return proc.process(start, level, recursive);
    }
  };
}      /* End namespace dd4hep               */
#endif // DD4HEP_VOLUMEPROCESSOR_H