withParallelData.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_WITHPARALLELDATA_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_WITHPARALLELDATA_H

// LArSoft libraries
#include "larcorealg/CoreUtils/ContainerMeta.h" // util::collection_value_t, ...
#include "lardata/RecoBaseProxy/ProxyBase/ParallelDataProxyMaker.h"
#include "lardata/RecoBaseProxy/ProxyBase/WithAssociatedStructBase.h"

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

namespace proxy {

  //----------------------------------------------------------------------------
  namespace details {

    template <typename Aux, typename ArgTuple, typename AuxTag = Aux>
    using WithParallelCollectionStruct =
      WithAssociatedStructBase<Aux,
                               void, // no metadata concept for parallel collections
                               ArgTuple,
                               ParallelDataProxyMakerWrapper<Aux, AuxTag>::template maker_t,
                               AuxTag>;

    template <typename Aux, typename ArgTuple, typename AuxColl, typename AuxTag = Aux>
    using WithWrappedParallelCollectionStruct = WithAssociatedStructBase<
      Aux,
      void, // no metadata concept for parallel collections
      ArgTuple,
      ParallelDataProxyMakerWrapper<Aux, AuxTag, AuxColl>::template maker_t,
      AuxTag>;

  } // namespace details

  // --- BEGIN Parallel data collections ---------------------------------------
  //----------------------------------------------------------------------------
  template <typename Aux, typename AuxTag, typename... Args>
  auto withParallelDataAs(Args&&... args)
  {
    using ArgTuple_t = std::tuple<Args&&...>;
    ArgTuple_t argsTuple(std::forward<Args>(args)...);
    return details::WithParallelCollectionStruct<Aux, ArgTuple_t, AuxTag>(std::move(argsTuple));
  } // withParallelDataAs()

  //----------------------------------------------------------------------------
  template <typename Aux, typename... Args>
  auto withParallelData(Args&&... args)
  {
    return withParallelDataAs<Aux, Aux>(std::forward<Args>(args)...);
  }

  //----------------------------------------------------------------------------
  template <typename AuxTag, typename AuxColl>
  auto wrapParallelDataAs(AuxColl const& auxColl)
  {
    std::tuple<AuxColl const&> args = {auxColl};
    return details::WithWrappedParallelCollectionStruct<util::collection_value_t<AuxColl>,
                                                        decltype(args),
                                                        AuxColl,
                                                        AuxTag>(std::move(args));
  } // wrapParallelDataAs()

  template <typename AuxColl>
  auto wrapParallelData(AuxColl const& auxColl)
  {
    return wrapParallelDataAs<util::collection_value_t<AuxColl>>(auxColl);
  }

  // --- END Parallel data collections -----------------------------------------

} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_PROXYBASE_WITHPARALLELDATA_H