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 <type_traits> // std::is_convertible<>
#include <utility>     // std::forward()

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