awaiters.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include "async.hpp"
#include "buffers.hpp"
 
#include <array>
#include <concepts>
#include <coroutine>
#include <functional>
#include <memory>
#include <optional>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace uni20::async
{
 
template <typename T> struct ValueAwaiter
{
    using value_type = T;
 
    T value;
 
    [[nodiscard]] bool await_ready() const noexcept { return true; }
 
    void await_suspend(BasicTask) const noexcept {}
 
    [[nodiscard]] T const& await_resume() const& noexcept { return value; }
 
    [[nodiscard]] T await_resume() && noexcept { return std::move(value); }
 
    void release() const noexcept {}
};
 
namespace detail
{
template <typename T> using member_read_awaiter_t = std::remove_cvref_t<decltype(std::declval<T>().read())>;
 
template <typename T>
concept AsyncReadProvider = requires(T&& value) { std::forward<T>(value).read(); } &&
                            TaskAwaitable<member_read_awaiter_t<T>> && requires(member_read_awaiter_t<T>& awaiter) {
                              typename member_read_awaiter_t<T>::value_type;
                              { awaiter.await_ready() } -> std::convertible_to<bool>;
                              awaiter.await_resume();
                            };
 
template <typename Result>
using all_result_element_t =
    std::conditional_t<std::is_lvalue_reference_v<Result>, Result, std::remove_cvref_t<Result>>;
 
template <typename Awaiter>
using all_result_t = all_result_element_t<decltype(std::declval<Awaiter>().await_resume())>;
} // namespace detail
 
template <typename T>
  requires(!detail::AsyncReadProvider<T>)
[[nodiscard]] auto read(T&& value) -> ValueAwaiter<std::remove_cvref_t<T>>
{
  return ValueAwaiter<std::remove_cvref_t<T>>{std::forward<T>(value)};
}
 
template <typename T>
  requires detail::AsyncReadProvider<T>
[[nodiscard]] decltype(auto) read(T&& value)
{
  return std::forward<T>(value).read();
}
 
template <TaskFactoryChildAwaitable... Aw>
  requires((!std::is_void_v<decltype(std::declval<Aw>().await_resume())> && ...))
struct AllAwaiter //: public AsyncAwaiter
{
    std::tuple<Aw...> bufs_;                  
    std::array<bool, sizeof...(Aw)> ready_{}; 
    int pending_ = sizeof...(Aw);             
 
    [[nodiscard]] bool await_ready() noexcept { return await_ready_impl(std::make_index_sequence<sizeof...(Aw)>{}); }
 
    [[nodiscard]] int num_awaiters() const noexcept { return pending_; }
 
#if UNI20_DEBUG_DAG
    template <typename F> void debug_each_dependency(F&& visit) const
    {
      std::apply([&](auto const&... awaiters) { (debug_visit_dependency(awaiters, visit), ...); }, bufs_);
    }
#endif
 
    void await_suspend(TaskFactory f) noexcept
    {
      await_suspend_impl(std::move(f), std::make_index_sequence<sizeof...(Aw)>{});
    }
 
    [[nodiscard]] auto await_resume()
    {
      return await_resume_impl(std::make_index_sequence<sizeof...(Aw)>{});
    }
 
  private:
#if UNI20_DEBUG_DAG
    template <typename A, typename F> static void debug_visit_dependency(A const& awaiter, F& visit)
    {
      if constexpr (requires {
                      awaiter.node();
                      awaiter.debug_task_role();
                    })
      {
        visit(awaiter.node(), awaiter.debug_task_role());
      }
    }
#endif
 
    template <std::size_t... I> bool await_ready_impl(std::index_sequence<I...>) noexcept
    {
      pending_ = 0;
      ((ready_[I] = std::get<I>(bufs_).await_ready(), pending_ += ready_[I] ? 0 : 1), ...);
      return pending_ == 0;
    }
 
    template <std::size_t... I> void await_suspend_impl(TaskFactory f, std::index_sequence<I...>) noexcept
    {
      ((ready_[I] ? void() : std::get<I>(bufs_).await_suspend(f.take_next())), ...);
    }
 
    template <std::size_t I> decltype(auto) await_resume_child()
    {
      using awaiter_type = std::tuple_element_t<I, std::tuple<Aw...>>;
      return std::forward<awaiter_type>(std::get<I>(bufs_)).await_resume();
    }
 
    template <std::size_t... I> auto await_resume_impl(std::index_sequence<I...>)
    {
      using result_type = std::tuple<detail::all_result_t<Aw>...>;
      return result_type{this->template await_resume_child<I>()...};
    }
};
 
namespace detail
{
template <typename T> struct MapToRefOrValue
{
    static_assert(std::is_trivially_move_constructible_v<T>,
                  "Prvalue passed to all(...) must be trivially move constructible");
    using type = T;
};
 
template <typename T> struct MapToRefOrValue<T&&>
{
    static_assert(std::is_trivially_move_constructible_v<T>,
                  "Rvalue passed to all(...) must be trivially move constructible");
    using type = T;
};
 
template <typename T> struct MapToRefOrValue<T&>
{
    using type = T&;
};
} // namespace detail
 
template <TaskFactoryChildAwaitable... Aw>
  requires((!std::is_void_v<decltype(std::declval<Aw>().await_resume())> && ...))
auto all(Aw&&... aw) noexcept
{
  return AllAwaiter<typename detail::MapToRefOrValue<Aw>::type...>(
      std::tuple<typename detail::MapToRefOrValue<Aw>::type...>(std::forward<Aw>(aw)...));
}
 
//------------------------------------------------------------------------------
// Non-blocking await: try_await
//------------------------------------------------------------------------------
 
template <typename T>
concept HasMemberCoAwait = requires(T t) { t.operator co_await(); };
 
template <typename T>
concept HasFreeCoAwait = (!HasMemberCoAwait<T> && requires(T t) { operator co_await(t); });
 
template <typename U> decltype(auto) get_awaiter(U&& u) noexcept
{
  if constexpr (HasMemberCoAwait<U>)
  {
    return std::forward<U>(u).operator co_await();
  }
  else if constexpr (HasFreeCoAwait<U>)
  {
    return operator co_await(std::forward<U>(u));
  }
  else
  {
    return std::forward<U>(u);
  }
}
 
template <typename Awt> struct TryAwaiter
{
    using Awaiter = std::remove_reference_t<Awt>;
    using StoredAwaiter = std::conditional_t<std::is_lvalue_reference_v<Awt>, Awaiter*, Awt>;
 
    StoredAwaiter awaiter_;
 
    constexpr explicit TryAwaiter(Awt aw) noexcept : awaiter_(store(std::forward<Awt>(aw))) {}
 
    [[nodiscard]] bool await_ready() const noexcept { return true; }
 
    void await_suspend(BasicTask t) noexcept { access().await_suspend(std::move(t)); }
 
    [[nodiscard]] auto await_resume()
    {
      auto& inner = access();
      using ResumeAwaiter = std::conditional_t<std::is_lvalue_reference_v<Awt>, Awaiter&, Awaiter&&>;
      using R = decltype(std::declval<ResumeAwaiter>().await_resume());
      using StoreT =
          std::conditional_t<std::is_lvalue_reference_v<R>, std::reference_wrapper<std::remove_reference_t<R>>,
                             std::remove_cvref_t<R>>;
 
      if (!inner.await_ready())
      {
        return std::optional<StoreT>{};
      }
 
      if constexpr (std::is_lvalue_reference_v<R>)
      {
        return std::optional<StoreT>{std::ref(resume_inner(inner))};
      }
      else
      {
        return std::optional<StoreT>{resume_inner(inner)};
      }
    }
 
  private:
    static constexpr StoredAwaiter store(Awt aw) noexcept
    {
      if constexpr (std::is_lvalue_reference_v<Awt>)
      {
        return std::addressof(aw);
      }
      else
      {
        return std::move(aw);
      }
    }
 
    [[nodiscard]] constexpr Awaiter& access() noexcept
    {
      if constexpr (std::is_lvalue_reference_v<Awt>)
      {
        return *awaiter_;
      }
      else
      {
        return awaiter_;
      }
    }
 
    [[nodiscard]] constexpr Awaiter const& access() const noexcept
    {
      if constexpr (std::is_lvalue_reference_v<Awt>)
      {
        return *awaiter_;
      }
      else
      {
        return awaiter_;
      }
    }
 
    [[nodiscard]] static decltype(auto) resume_inner(Awaiter& inner)
    {
      if constexpr (std::is_lvalue_reference_v<Awt>)
      {
        return inner.await_resume();
      }
      else
      {
        return std::move(inner).await_resume();
      }
    }
};
 
template <typename Aw> constexpr auto try_await(Aw& aw) noexcept { return TryAwaiter<Aw&>{aw}; }
 
template <typename Aw> constexpr auto try_await(Aw&& aw) noexcept
{
  static_assert(std::is_trivially_move_constructible_v<Aw>, "try_await(x) on prvalues requires T to be safely movable");
  return TryAwaiter<Aw>{std::move(aw)};
}
 
namespace detail
{
template <typename T, typename Value> class WriteToAwaiter {
  public:
    WriteToAwaiter(WriteBuffer<T>&& buffer, Value&& value)
        : buffer_(std::move(buffer)), value_(std::forward<Value>(value))
    {
      static_assert(std::constructible_from<T, Value&&>, "Value must be constructible as T for WriteBuffer<T>");
    }
 
    [[nodiscard]] bool await_ready() const noexcept { return buffer_.await_ready(); }
 
    auto await_suspend(BasicTask&& t) noexcept { return buffer_.await_suspend(std::move(t)); }
 
    void await_resume() { buffer_.emplace_assert(std::move(value_)); }
 
  private:
    WriteBuffer<T> buffer_;
    std::remove_reference_t<Value> value_;
};
} // namespace detail
 
template <typename T, typename Value> auto write_to(WriteBuffer<T>&& buffer, Value value)
{
  return detail::WriteToAwaiter<T, Value>(std::move(buffer), std::move(value));
}
 
} // namespace uni20::async