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


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