OneTo01DataProxyMaker.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_ONETO01DATAPROXYMAKER_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_ONETO01DATAPROXYMAKER_H

// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase/OneTo01Data.h"
#include "lardata/RecoBaseProxy/ProxyBase/makeOneTo01dataFrom.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 LArSoftProxiesAssociatedData ------------------------------------

  //----------------------------------------------------------------------------
  //--- one-to-(zero/one) associations
  //----------------------------------------------------------------------------
  template <typename Main, typename Aux, typename Metadata = void, typename AuxTag = Aux>
  struct OneTo01DataProxyMakerBase {

    using data_tag = AuxTag;

    using main_element_t = Main;

    using aux_element_t = Aux;

    using metadata_t = Metadata;

    using aux_collection_proxy_t =
      details::OneTo01Data<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&& handle, MainArgs const&, Assns const& assns)
    {
      static_assert(std::is_convertible<typename Assns::right_t, aux_element_t>(),
                    "Improper right type for one-to-(zero-or-one) association.");
      return makeOneTo01dataFrom<data_tag>(assns, handle->size());
    }

  private:
    template <typename Event, typename Handle>
    static auto createFromTag(Event const& event,
                              Handle&& mainHandle,
                              art::InputTag const& auxInputTag)
    {
      return makeOneTo01dataFrom<main_element_t, aux_element_t, metadata_t, data_tag>(
        event, auxInputTag, mainHandle->size());
    }

  }; // struct OneTo01DataProxyMakerBase<>

  //--------------------------------------------------------------------------
  template <typename Main, typename Aux, typename Metadata, typename CollProxy, typename Tag = Aux>
  class OneTo01DataProxyMaker : public OneTo01DataProxyMakerBase<Main, Aux, Metadata, Tag> {
    //
    // Note that this implementation is here only to document how to derive
    // a OneTo01DataProxyMaker (specialization) from
    // OneTo01DataProxyMakerBase. It's just mirroring the base class.
    //
    using base_t = OneTo01DataProxyMakerBase<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 OneTo01DataProxyMaker<>

  // --- END LArSoftProxiesAssociatedData --------------------------------------

  namespace details {

    //--------------------------------------------------------------------------
    //---  Stuff for one-to-(zero or one) associated data
    //--------------------------------------------------------------------------
    template <typename Aux, typename Metadata /* = void */, typename AuxTag /* = Aux */
              >
    struct OneTo01DataProxyMakerWrapper {
      template <typename CollProxy>
      using maker_t =
        OneTo01DataProxyMaker<typename CollProxy::main_element_t, Aux, Metadata, CollProxy, AuxTag>;
    };

  } // namespace details

} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_PROXYBASE_ONETO01DATAPROXYMAKER_H