withAssociated.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_WITHASSOCIATED_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_WITHASSOCIATED_H

// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase/WithAssociatedStructBase.h"
#include "lardata/RecoBaseProxy/ProxyBase/AssociatedDataProxyMaker.h"

// C/C++ standard libraries
#include <tuple>
#include <utility> // std::forward(), std::move()
  

namespace proxy {
  
  //----------------------------------------------------------------------------
  namespace details {
    
    //--------------------------------------------------------------------------
    template <
      typename Aux, typename Metadata,
      typename ArgTuple, typename AuxTag = Aux
      >
    using WithAssociatedStruct = WithAssociatedStructBase<
      Aux,
      Metadata,
      ArgTuple,
      AssociatedDataProxyMakerWrapper<Aux, Metadata, AuxTag>::template maker_t,
      AuxTag
      >;
    
    //--------------------------------------------------------------------------
    
  } // namespace details
  
  
  // --- BEGIN One-to-many sequential associations -----------------------------
  //----------------------------------------------------------------------------
  template <typename Aux, typename Metadata, typename AuxTag, typename... Args>
  auto withAssociatedMetaAs(Args&&... args) {
    using ArgTuple_t = std::tuple<Args&&...>;
    ArgTuple_t argsTuple(std::forward<Args>(args)...);
    return details::WithAssociatedStruct<Aux, Metadata, ArgTuple_t, AuxTag>
      (std::move(argsTuple));
  } // withAssociatedMetaAs()
  
  
  //----------------------------------------------------------------------------
  template <typename Aux, typename AuxTag, typename... Args>
  auto withAssociatedAs(Args&&... args)
    {
      return withAssociatedMetaAs<Aux, void, AuxTag>
        (std::forward<Args>(args)...);
    }
  
  
  //----------------------------------------------------------------------------
  template <typename Aux, typename Metadata, typename... Args>
  auto withAssociatedMeta(Args&&... args)
    {
      return withAssociatedMetaAs<Aux, Metadata, Aux>
        (std::forward<Args>(args)...); 
    }
  
  
  template <typename Aux, typename... Args>
  auto withAssociated(Args&&... args)
    { return withAssociatedMeta<Aux, void>(std::forward<Args>(args)...); }
  
  
  //----------------------------------------------------------------------------
  template <typename AuxTag, typename Assns>
  auto wrapAssociatedAs(Assns const& assns)
    {
      using Aux_t = typename Assns::right_t;
      using Metadata_t = lar::util::assns_metadata_t<Assns>;
      return
        details::WithAssociatedStruct<Aux_t, Metadata_t, std::tuple<>, AuxTag>
        ({});
    } // wrapAssociatedAs()
  
  
  template <typename Assns>
  auto wrapAssociated(Assns const& assns)
    { return wrapAssociatedAs<typename Assns::right_t>(assns); }
  
  
  template <typename AuxTag, typename Assns>
  auto wrapAssociated(Assns const& assns)
    { return wrapAssociatedAs<AuxTag>(assns); }
  
  //----------------------------------------------------------------------------
  
} // namespace proxy


#endif // LARDATA_RECOBASEPROXY_PROXYBASE_WITHASSOCIATED_H