AssociatedDataProxyMaker.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_ASSOCIATEDDATAPROXYMAKER_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_ASSOCIATEDDATAPROXYMAKER_H

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

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

// C/C++ standard libraries
#include <utility> // std::forward()
#include <type_traits> // std::is_convertible<>


namespace proxy {
  
  
  // --- BEGIN Associated data infrastructure ----------------------------------
  
  //----------------------------------------------------------------------------
  //--- one-to-many associations
  //----------------------------------------------------------------------------
  template
    <typename Main, typename Aux, typename Metadata, typename AuxTag = Aux>
  struct AssociatedDataProxyMakerBase {
    
    using data_tag = AuxTag;
    
    using main_element_t = Main;
    
    using aux_element_t = Aux;
    
    using metadata_t = Metadata;
    
    using aux_collection_proxy_t = details::AssociatedData
      <main_element_t, aux_element_t, metadata_t, data_tag>;
    
    using assns_t = typename aux_collection_proxy_t::assns_t;
    
    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, typename Assns>
    static auto make
      (Event const&, Handle&&, MainArgs const&, Assns const& assns)
      {
        static_assert(
          std::is_convertible<typename Assns::right_t, aux_element_t>(),
          "Improper right type for association."
          );
        return makeAssociatedDataFrom<data_tag>(assns);
      }
    
    
      private:
    template<typename Event, typename Handle>
    static auto createFromTag(
      Event const& event, Handle&& mainHandle,
      art::InputTag const& auxInputTag
      )
      {
        return makeAssociatedDataFrom
          <main_element_t, aux_element_t, metadata_t, data_tag>
          (event, auxInputTag, mainHandle->size());
      }
    
  }; // struct AssociatedDataProxyMakerBase<>
  
  
  
  //--------------------------------------------------------------------------
  template <
    typename Main, typename Aux, typename Metadata,
    typename CollProxy, typename Tag = Aux
    >
  class AssociatedDataProxyMaker
    : public AssociatedDataProxyMakerBase<Main, Aux, Metadata, Tag>
  {
    //
    // Note that this implementation is here only to document how to derive
    // a AssociatedDataProxyMaker (specialization) from
    // AssociatedDataProxyMakerBase. It's just mirroring the base class.
    //
    using base_t = AssociatedDataProxyMakerBase<Main, Aux, Metadata, Tag>;
    
      public:
    
    using typename base_t::main_element_t;
    
    using typename base_t::aux_element_t;
    
    using typename base_t::metadata_t;
    
    using typename base_t::aux_collection_proxy_t;
    
    using typename base_t::assns_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 AssociatedDataProxyMaker<>
  
  // --- END Associated data infrastructure ------------------------------------
  
  
  
  //----------------------------------------------------------------------------
  namespace details {
    
    template <
      typename Aux, typename Metadata /* = void */,
      typename AuxTag /* = Aux */
      >
    struct AssociatedDataProxyMakerWrapper {
      template <typename CollProxy>
      using maker_t = AssociatedDataProxyMaker
        <typename CollProxy::main_element_t, Aux, Metadata, CollProxy, AuxTag>;
    };
    
    
  } // namespace details
  
  
} // namespace proxy


#endif // LARDATA_RECOBASEPROXY_PROXYBASE_ASSOCIATEDDATAPROXYMAKER_H