ParallelDataProxyMaker.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATAPROXYMAKER_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATAPROXYMAKER_H

// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase/makeParallelDataFrom.h"
#include "lardata/RecoBaseProxy/ProxyBase/ParallelData.h"
#include "larcorealg/CoreUtils/ContainerMeta.h" // util::collection_value_t, ...

// framework libraries
#include "canvas/Utilities/InputTag.h"

// C/C++ standard 
#include <vector>
#include <utility> // std::forward()



namespace proxy {
  
  
  // -- BEGIN Parallel data infrastructure -------------------------------------
  template <
    typename Main,
    typename AuxColl,
    typename Aux,
    typename AuxTag = util::collection_value_t<AuxColl>
    >
  struct ParallelDataProxyMakerBase {
    
    using data_tag = AuxTag;
    
    using main_element_t = Main;
    
    using aux_collection_t = AuxColl;
    
    using aux_element_t = Aux;
    
    using aux_collection_proxy_t
       = details::ParallelData<aux_collection_t, aux_element_t, data_tag>;
    
    template<typename Event, typename Handle, typename MainArgs>
    static auto make
      (Event const& event, Handle&& mainHandle, MainArgs const& mainArgs)
      {
        return createFromTag
          (event, std::forward<Handle>(mainHandle), art::InputTag(mainArgs));
      }
    
    template<typename Event, typename Handle, typename MainArgs>
    static auto make(
      Event const& event, Handle&& mainHandle,
      MainArgs const&, art::InputTag const& auxInputTag
      )
      {
        return
          createFromTag(event, std::forward<Handle>(mainHandle), auxInputTag);
      }
    
    template<typename Event, typename Handle, typename MainArgs>
    static auto make
      (Event const&, Handle&&, MainArgs const&, aux_collection_t const& auxColl)
      {
        return makeParallelDataFrom<aux_collection_t, aux_element_t, data_tag>
          (auxColl);
      }
    
    
      private:
    template<typename Event, typename Handle>
    static auto createFromTag
      (Event const& event, Handle&&, art::InputTag const& auxInputTag)
      {
        return makeParallelDataFrom<aux_collection_t, aux_element_t, data_tag>
          (event, auxInputTag);
      }
    
  }; // struct ParallelDataProxyMakerBase<>
  
  
  //--------------------------------------------------------------------------
  template<
    typename Main, typename Aux, typename CollProxy, typename Tag = Aux,
    typename AuxColl = std::vector<Aux>
    >
  class ParallelDataProxyMaker
    : public ParallelDataProxyMakerBase<Main, AuxColl, Aux, Tag>
  {
    //
    // Note that this implementation is here only to document how to derive
    // a ParallelDataProxyMaker (specialization) from
    // ParallelDataProxyMakerBase. It's just mirroring the base class.
    //
    using base_t = ParallelDataProxyMakerBase<Main, AuxColl, Aux, Tag>;
    
      public:
    
    using typename base_t::main_element_t;
    
    using typename base_t::aux_collection_t;
    
    using typename base_t::aux_element_t;
    
    using typename base_t::aux_collection_proxy_t;
    
    
    template
      <typename Event, typename Handle, typename MainArgs, typename... Args>
    static auto make(
      Event const& event, Handle&& mainHandle, MainArgs const& margs,
      Args&&... args
      )
      {
        return base_t::make(
          event,
          std::forward<Handle>(mainHandle),
          margs,
          std::forward<Args>(args)...
          );
      }
    
  }; // struct ParallelDataProxyMaker<>
  
  
  // -- END Parallel data infrastructure ---------------------------------------
  
  
  //----------------------------------------------------------------------------
  namespace details {
    
    //--------------------------------------------------------------------------
    //--- stuff for parallel data collection (a form of auxiliary data)
    //--------------------------------------------------------------------------
    template <typename Aux, typename AuxTag, typename AuxColl = void>
    struct ParallelDataProxyMakerWrapper {
      template <typename CollProxy>
      using maker_t = ParallelDataProxyMaker
        <typename CollProxy::main_element_t, Aux, CollProxy, AuxTag, AuxColl>;
    }; // struct ParallelDataProxyMakerWrapper<Aux, AuxTag, AuxColl>
    
    template <typename Aux, typename AuxTag>
    struct ParallelDataProxyMakerWrapper<Aux, AuxTag, void> {
      template <typename CollProxy>
      using maker_t = ParallelDataProxyMaker
        <typename CollProxy::main_element_t, Aux, CollProxy, AuxTag>;
    }; // struct ParallelDataProxyMakerWrapper<Aux, AuxTag>
    
    
  } // namespace details
  
  
} // namespace proxy


#endif // LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATAPROXYMAKER_H