uvco::Promise< T >::PromiseAwaiter_ Struct Reference

#include <promise.h>

Collaboration diagram for uvco::Promise< T >::PromiseAwaiter_:

Public Member Functions
	PromiseAwaiter_ (PromiseCore_ &core)
	PromiseAwaiter_ (PromiseAwaiter_ &&)=delete
	PromiseAwaiter_ (const PromiseAwaiter_ &)=delete
PromiseAwaiter_ &	operator= (PromiseAwaiter_ &&)=delete
PromiseAwaiter_ &	operator= (const PromiseAwaiter_ &)=delete
	~PromiseAwaiter_ ()=default
bool	await_ready () const
bool	await_suspend (std::coroutine_handle<> handle) const
T	await_resume () const

Public Attributes
PromiseCore_ &	core_

Detailed Description

template<typename T>
struct uvco::Promise< T >::PromiseAwaiter_

Returned as awaiter object when co_awaiting a promise.

Handles suspension of current coroutine and resumption upon fulfillment of the awaited promise.

Constructor & Destructor Documentation

PromiseAwaiter_() [1/3]

template<typename T >

uvco::Promise< T >::PromiseAwaiter_::PromiseAwaiter_ ( PromiseCore_ &  core )

inlineexplicit

The core is shared with the promise and contains the resumption handle, and ultimately the returned value. Because the awaiter object is only used while a coroutine is waiting on a co_await suspension point, we can use a reference to the PromiseCore_ object.

: core_{core} {}

PromiseAwaiter_() [2/3]

template<typename T >

uvco::Promise< T >::PromiseAwaiter_::PromiseAwaiter_ ( PromiseAwaiter_ &&  )

delete

PromiseAwaiter_() [3/3]

template<typename T >

uvco::Promise< T >::PromiseAwaiter_::PromiseAwaiter_ ( const PromiseAwaiter_ &  )

delete

~PromiseAwaiter_()

template<typename T >

uvco::Promise< T >::PromiseAwaiter_::~PromiseAwaiter_ ( )

default

Member Function Documentation

await_ready()

template<typename T >

bool uvco::Promise< T >::PromiseAwaiter_::await_ready ( ) const

inline

Part of the coroutine protocol: returns true if the promise is already fulfilled.

{ return core_.ready(); }

await_resume()

template<typename T >

T uvco::Promise< T >::PromiseAwaiter_::await_resume ( ) const

inline

Part of the coroutine protocol: extracts the resulting value from the promise core and returns it.

                           {
      if (core_.stale()) {
        throw UvcoException(
            "co_await called on previously finished promise (T)");
      }
      if (core_.slot.has_value()) {
        switch (core_.slot->index()) {
        case 0: {
          T result = std::move(std::get<0>(core_.slot.value()));
          core_.slot.reset();
          return std::move(result);
        }
        case 1:
          std::rethrow_exception(std::get<1>(core_.slot.value()));
        default:
          throw UvcoException("PromiseAwaiter_::await_resume: invalid slot");
        }
      }
      throw UvcoException("await_resume called on unfulfilled promise (bug?)");
    }

await_suspend()

template<typename T >

bool uvco::Promise< T >::PromiseAwaiter_::await_suspend ( std::coroutine_handle<>  handle ) const

inline

Part of the coroutine protocol: returns if suspension is desired (always true), and stores the awaiting coroutine state in the PromiseCore.

                                                                         {
      BOOST_ASSERT_MSG(!core_.willResume(),
                       "promise is already being waited on!");
      core_.setHandle(handle);
      return true;
    }

operator=() [1/2]

template<typename T >

PromiseAwaiter_ & uvco::Promise< T >::PromiseAwaiter_::operator= ( const PromiseAwaiter_ &  )

delete

operator=() [2/2]

template<typename T >

PromiseAwaiter_ & uvco::Promise< T >::PromiseAwaiter_::operator= ( PromiseAwaiter_ &&  )

delete

Member Data Documentation

core_

template<typename T >

PromiseCore_& uvco::Promise< T >::PromiseAwaiter_::core_

---

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

• uvco/promise/promise.h