withParallelData.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_WITHPARALLELDATA_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_WITHPARALLELDATA_H

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

// 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