uvco::SelectSet< Ts > Class Template Reference

#include <select.h>

Public Types
using	Variant = std::variant<Promise<Ts> *...>
using	Tuple = std::tuple<Promise<Ts> *...>

Public Member Functions
	SelectSet (Promise< Ts > &...promises)
	~SelectSet ()
bool	await_ready () noexcept
std::coroutine_handle	await_suspend (std::coroutine_handle<> handle)
std::vector< Variant >	await_resume ()

Private Member Functions
template<size_t Ix = 0>
void	checkPromises (std::vector< Variant > &readyPromises)

Private Attributes
Tuple	promises_
std::coroutine_handle	suspended_
bool	resumed_ = false

Detailed Description

template<typename... Ts>
class uvco::SelectSet< Ts >

A SelectSet is a set of promises that are awaited simultaneously. The first promise that is ready is returned. If no promise is ready, the coroutine is suspended until one of the promises is ready.

See also waitAny() for a more convenient approach that internally utilizes this class.

The SelectSet is directly awaitable. For example:

Promise<int> promise1 = []() -> Promise<int> { co_return 1; }();
Promise<int> promise2 = []() -> Promise<int> { co_return 2; }();
std::vector<std::variant<Promise<int>, Promise<int>>> results = co_await
SelectSet{promise1, promise2};
ASSERT_EQ(2, results.size());
EXPECT_EQ(0, results[0].index()); // Order is unspecified usually
EXPECT_EQ(1, std::get<0>(results[0]).unwrap()); // or co_await
 
// Easy approach, no second co_await:
std::vector<std::variant<int, int>> results2 = co_await waitAny(promise1,
promise2); ASSERT_EQ(2, results.size()); EXPECT_EQ(0, results[0].index());
// Order is unspecified usually

It is okay to add an already finished promise to a SelectSet.

A given SelectSet can only be awaited once. Usually, as shown above, it's best used as a temporary; it only takes references to the promises being selected from, and is therefore cheaply constructible.

It is possible that no events are returned ("spurious wakeup"); make sure that you can handle an empty result vector.

Member Typedef Documentation

Tuple

template<typename... Ts>

using uvco::SelectSet< Ts >::Tuple = std::tuple<Promise<Ts> *...>

Variant

template<typename... Ts>

using uvco::SelectSet< Ts >::Variant = std::variant<Promise<Ts> *...>

Constructor & Destructor Documentation

SelectSet()

template<typename... Ts>

uvco::SelectSet< Ts >::SelectSet ( Promise< Ts > &... promises )

inlineexplicit

: promises_{&promises...} {}

~SelectSet()

template<typename... Ts>

uvco::SelectSet< Ts >::~SelectSet ( )

inline

               {
    if (!resumed_) {
      std::apply(
          [](auto *...promise) { (promise->core()->resetHandle(), ...); },
          promises_);
    }
  }

Member Function Documentation

await_ready()

template<typename... Ts>

bool uvco::SelectSet< Ts >::await_ready ( )

inlinenodiscardnoexcept

                                            {
    BOOST_ASSERT_MSG(!resumed_, "A select set can only be used once");
    const bool isReady = std::apply(
        [](auto *...promise) -> bool { return (promise->ready() || ...); },
        promises_);
    resumed_ |= isReady;
    return isReady;
  }

await_resume()

template<typename... Ts>

std::vector< Variant > uvco::SelectSet< Ts >::await_resume ( )

inline

Returns all promises that are ready. It is possible that no promise is ready, and the returned vector is empty, in the case that two promises were ready at once; one promise scheduled the SelectSet for resumption, we delivered both events, and will be woken up a second time.

TODO: provide a no-/rare-allocation API by reusing a vector or span.

                                    {
    resumed_ = true;
    std::vector<Variant> readyPromises;
    checkPromises(readyPromises);
    // Prevent the current coroutine from being resumed again, if another
    // promise in the SelectSet became ready in the meantime.
    if (suspended_ != nullptr) {
      Loop::cancel(suspended_);
      suspended_ = nullptr;
    }
    return readyPromises;
  }

await_suspend()

template<typename... Ts>

std::coroutine_handle uvco::SelectSet< Ts >::await_suspend ( std::coroutine_handle<> handle )

inline

Register the current coroutine to be resumed when one of the promises is ready.

                                                                    {
    std::apply(
        [handle](auto *...promise) {
          ((!promise->core()->stale() ? promise->core()->setHandle(handle)
                                      : (void)0),
           ...);
        },
        promises_);
    suspended_ = handle;
    return Loop::getNext();
  }

checkPromises()

template<typename... Ts>

template<size_t Ix = 0>

void uvco::SelectSet< Ts >::checkPromises ( std::vector< Variant > & readyPromises )

inlineprivate

                                                        {
    if constexpr (Ix < sizeof...(Ts)) {
      using PromisePtr = std::tuple_element_t<Ix, Tuple>;
      PromisePtr promise = std::get<Ix>(promises_);
      if (promise->ready()) {
        readyPromises.emplace_back(std::in_place_index<Ix>, promise);
      } else {
        // Reset promises to `init` state and remove the current coroutine's
        // handle from them so they don't resume us later.
        promise->core()->resetHandle();
      }
      checkPromises<Ix + 1>(readyPromises);
    }
  }

Member Data Documentation

promises_

template<typename... Ts>

Tuple uvco::SelectSet< Ts >::promises_

private

resumed_

template<typename... Ts>

bool uvco::SelectSet< Ts >::resumed_ = false

private

suspended_

template<typename... Ts>

std::coroutine_handle uvco::SelectSet< Ts >::suspended_

private

---

The documentation for this class was generated from the following file:

• uvco/promise/select.h