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/AssociatedDataProxyMaker.h"
#include "lardata/RecoBaseProxy/ProxyBase/WithAssociatedStructBase.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