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 () const noexcept
void	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_
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.

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};

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

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_{std::move(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 ( ) const

inlinenoexcept

                                                  {
    return resumed_ || std::apply(
                           [](auto &&...promise) -> bool {
                             return (promise.ready() || ...);
                           },
                           promises_);
  }

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);
    return readyPromises;
  }

await_suspend()

template<typename... Ts>

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

inline

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

                                                   {
    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_);
  }

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 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);
    }
  }

Member Data Documentation

promises_

template<typename... Ts>

Tuple uvco::SelectSet< Ts >::promises_

private

resumed_

template<typename... Ts>

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

private

---

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

• uvco/promise/select.h