ParallelDataProxyMaker.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATAPROXYMAKER_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATAPROXYMAKER_H

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

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

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

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