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 <tuple> // std::tuple_element_t<>, std::get(), ...
#include <utility> // std::forward(), std::move(), std::make_index_sequence()...
#include <type_traits> // std::is_convertible<>, std::decay_t<>, ...
#include <cstdlib> // std::size_t


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