select.h

Go to the documentation of this file.

// uvco (c) 2023 Lewin Bormann. See LICENSE for specific terms.
 
#pragma once
 
#include <fmt/core.h>
#include <fmt/ranges.h>
 
#include "uvco/promise/promise.h"
 
#include <coroutine>
#include <tuple>
#include <utility>
#include <variant>
#include <vector>
 
namespace uvco {
 
 
template <typename... Ts> class SelectSet {
public:
  using Variant = std::variant<Promise<Ts>...>;
  using Tuple = std::tuple<Promise<Ts>...>;
 
  explicit SelectSet(Promise<Ts>... promises)
      : promises_{std::move(promises)...} {}
 
  ~SelectSet() {
    if (!resumed_) {
      std::apply(
          [](auto &&...promise) { (promise.core()->resetHandle(), ...); },
          promises_);
    }
  }
 
  [[nodiscard]] bool await_ready() const noexcept {
    return resumed_ || std::apply(
                           [](auto &&...promise) -> bool {
                             return (promise.ready() || ...);
                           },
                           promises_);
  }
 
  void await_suspend(std::coroutine_handle<> handle) {
    BOOST_ASSERT_MSG(!resumed_, "A select set can only be used once");
    std::apply(
        [handle](auto &&...promise) {
          ((!promise.core()->stale() ? promise.core()->setHandle(handle)
                                     : (void)0),
           ...);
        },
        promises_);
  }
 
  std::vector<Variant> await_resume() {
    resumed_ = true;
    std::vector<Variant> readyPromises;
    checkPromises(readyPromises);
    return readyPromises;
  }
 
private:
  template <size_t Ix = 0>
  void checkPromises(std::vector<Variant> &readyPromises) {
    if constexpr (Ix < sizeof...(Ts)) {
      using PromiseType = std::tuple_element_t<Ix, Tuple>;
      PromiseType &promise = std::get<Ix>(promises_);
      if (promise.ready()) {
        readyPromises.emplace_back(std::in_place_index<Ix>, std::move(promise));
      } else {
        promise.core()->resetHandle();
      }
      checkPromises<Ix + 1>(readyPromises);
    }
  }
 
  Tuple promises_;
  bool resumed_ = false;
};
 
 
} // namespace uvco