wait_all_checked.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <chrono>
#include <vector>
 
#include <userver/engine/deadline.hpp>
#include <userver/engine/future_status.hpp>
#include <userver/utils/impl/span.hpp>
#include <userver/utils/meta.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace engine {
 
template <typename... Tasks>
void WaitAllChecked(Tasks&... tasks);
 
template <typename... Tasks, typename Rep, typename Period>
[[nodiscard]] FutureStatus WaitAllCheckedFor(
    const std::chrono::duration<Rep, Period>& duration, Tasks&... tasks);
 
template <typename... Tasks, typename Clock, typename Duration>
[[nodiscard]] FutureStatus WaitAllCheckedUntil(
    const std::chrono::time_point<Clock, Duration>& until, Tasks&... tasks);
 
template <typename... Tasks>
[[nodiscard]] FutureStatus WaitAllCheckedUntil(Deadline deadline,
                                               Tasks&... tasks);
 
namespace impl {
 
class ContextAccessor;
 
FutureStatus DoWaitAllChecked(utils::impl::Span<ContextAccessor*> targets,
                              Deadline deadline);
 
template <typename Container>
FutureStatus WaitAllCheckedFromContainer(Deadline deadline, Container& tasks) {
  std::vector<ContextAccessor*> targets;
  targets.reserve(std::size(tasks));
 
  for (auto& task : tasks) {
    targets.push_back(task.TryGetContextAccessor());
  }
 
  return impl::DoWaitAllChecked(targets, deadline);
}
 
template <typename... Tasks>
FutureStatus WaitAllCheckedFromTasks(Deadline deadline, Tasks&... tasks) {
  ContextAccessor* targets[]{tasks.TryGetContextAccessor()...};
  return impl::DoWaitAllChecked(targets, deadline);
}
 
inline FutureStatus WaitAllCheckedFromTasks(Deadline /*deadline*/) {
  return FutureStatus::kReady;
}
 
void HandleWaitAllStatus(FutureStatus status);
 
}  // namespace impl
 
template <typename... Tasks>
void WaitAllChecked(Tasks&... tasks) {
  impl::HandleWaitAllStatus(engine::WaitAllCheckedUntil(Deadline{}, tasks...));
}
 
template <typename... Tasks, typename Rep, typename Period>
[[nodiscard]] FutureStatus WaitAllCheckedFor(
    const std::chrono::duration<Rep, Period>& duration, Tasks&... tasks) {
  return WaitAllCheckedUntil(Deadline::FromDuration(duration), tasks...);
}
 
template <typename... Tasks, typename Clock, typename Duration>
[[nodiscard]] FutureStatus WaitAllCheckedUntil(
    const std::chrono::time_point<Clock, Duration>& until, Tasks&... tasks) {
  return WaitAllCheckedUntil(Deadline::FromTimePoint(until), tasks...);
}
 
template <typename... Tasks>
[[nodiscard]] FutureStatus WaitAllCheckedUntil(Deadline deadline,
                                               Tasks&... tasks) {
  if constexpr (meta::impl::IsSingleRange<Tasks...>()) {
    return impl::WaitAllCheckedFromContainer(deadline, tasks...);
  } else {
    return impl::WaitAllCheckedFromTasks(deadline, tasks...);
  }
}
 
}  // namespace engine
 
USERVER_NAMESPACE_END