WithProxyAsAuxStructBase.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_WITHPROXYASAUXSTRUCTBASE_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_WITHPROXYASAUXSTRUCTBASE_H

// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase/ProxyAsAuxProxyMaker.h"

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

// C/C++ standard
#include <cstdlib>     // std::size_t
#include <tuple>       // std::tuple_element_t<>, std::get(), ...
#include <type_traits> // std::is_convertible<>, std::decay_t<>, ...
#include <utility>     // std::forward(), std::move(), std::make_index_sequence()...

namespace proxy {

  namespace details {


    //--------------------------------------------------------------------------
    template <typename AuxProxy, typename ArgTuple, typename AuxTag = AuxProxy>
    class WithProxyAsAuxStructBase {

      static_assert(
        std::is_convertible<std::decay_t<std::tuple_element_t<0U, ArgTuple>>, art::InputTag>(),
        "The first argument of WithProxyAsAuxStructBase must be art::InputTag.");

      template <typename CollProxy>
      using main_t = typename CollProxy::main_element_t;

      using aux_proxy_t = AuxProxy;

      using tag = AuxTag;

      template <typename CollProxy>
      using proxy_maker_t = ProxyAsAuxProxyMaker<main_t<CollProxy>, aux_proxy_t, CollProxy, tag>;

    public:
      WithProxyAsAuxStructBase(ArgTuple&& args) : args(std::move(args)) {}

      template <typename CollProxy, typename Event, typename Handle, typename MainArgs>
      auto createAuxProxyMaker(Event const& event, Handle&& mainHandle, MainArgs const& mainArgs)
      {
        return createAuxProxyImpl<CollProxy>(
          event, std::forward<Handle>(mainHandle), mainArgs, std::make_index_sequence<NArgs>());
      } // construct()

    protected:
      ArgTuple args; 

      static constexpr std::size_t NArgs = std::tuple_size<ArgTuple>();

      // this method allows unpacking the arguments from the tuple
      template <typename CollProxy,
                typename Event,
                typename Handle,
                typename MainArgs,
                std::size_t... I>
      auto createAuxProxyImpl(Event const& event,
                              Handle&& mainHandle,
                              MainArgs const& mainArgs,
                              std::index_sequence<I...>)
      {
        return proxy_maker_t<CollProxy>::make(
          event, mainHandle, mainArgs, std::get<I>(std::forward<ArgTuple>(args))...);
      }

    }; // struct WithProxyAsAuxStructBase


  } // namespace details

} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_PROXYBASE_WITHPROXYASAUXSTRUCTBASE_H