when_all.hpp

Go to the documentation of this file.

#pragma once
 
#include <yaclib/algo/detail/result_core.hpp>
#include <yaclib/async/when/all.hpp>
#include <yaclib/async/when/all_tuple.hpp>
#include <yaclib/async/when/join.hpp>
#include <yaclib/async/when/when.hpp>
#include <yaclib/config.hpp>
#include <yaclib/util/fail_policy.hpp>
#include <yaclib/util/type_traits.hpp>
 
namespace yaclib {
 
template <typename Core, FailPolicy F>
using ContainerElem = std::conditional_t<F == FailPolicy::FirstFail, wrap_void_t<typename Core::Value>,
                                         typename Core::Trait::template Result<typename Core::Value>>;
 
template <FailPolicy F = FailPolicy::FirstFail, typename... Futures,
          typename = std::enable_if_t<(... && is_combinator_input_v<Futures>)>>
YACLIB_INLINE auto WhenAll(Futures... futures) {
  when::CheckSameTrait<Futures...>();
 
  using Head = typename head_t<Futures...>::Core;
  using Value = typename Head::Value;
  using OutputTrait = typename Head::Trait;
 
  if constexpr ((... && std::is_same_v<Value, typename Futures::Core::Value>)) {
    if constexpr (std::is_same_v<Value, void> && F != FailPolicy::None) {
      return when::When<when::Join, F, void, OutputTrait>(std::move(futures)...);
    } else {
      using OutputValue = std::vector<ContainerElem<Head, F>>;
      return when::When<when::All, F, OutputValue, OutputTrait>(std::move(futures)...);
    }
  } else {
    using OutputValue = std::tuple<ContainerElem<typename Futures::Core, F>...>;
    return when::When<when::AllTuple, F, OutputValue, OutputTrait>(std::move(futures)...);
  }
}
 
template <FailPolicy F = FailPolicy::FirstFail, typename It, typename = std::enable_if_t<is_input_iterator_v<It>>>
YACLIB_INLINE auto WhenAll(It begin, std::size_t count) {
  using T = typename std::iterator_traits<It>::value_type;
  using OutputTrait = typename T::Core::Trait;
 
  if constexpr (std::is_same_v<typename T::Core::Value, void> && F != FailPolicy::None) {
    return when::When<when::Join, F, void, OutputTrait>(begin, count);
  } else {
    using OutputValue = std::vector<ContainerElem<typename T::Core, F>>;
    return when::When<when::All, F, OutputValue, OutputTrait>(begin, count);
  }
}
 
template <FailPolicy F = FailPolicy::FirstFail, typename It, typename Sentinel,
          typename = std::enable_if_t<is_input_range_pair_v<It, Sentinel>>>
YACLIB_INLINE auto WhenAll(It begin, Sentinel end) {
  static_assert(
    has_constant_time_distance_v<It, Sentinel>,
    "Use WhenAll(begin, std::distance(begin, end)) instead");  // We don't use std::distance because we want to alert
                                                               // the user to the fact that it can be expensive.
 
  return WhenAll<F>(begin, static_cast<std::size_t>(end - begin));
}
 
template <FailPolicy F = FailPolicy::FirstFail, typename Range, typename = std::enable_if_t<is_input_range_v<Range>>>
YACLIB_INLINE auto WhenAll(Range&& range) {
  return WhenAll<F>(std::begin(range), std::end(range));
}
 
}  // namespace yaclib