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

Handles the actual suspension and resumption. More...

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

Public Member Functions
	PromiseAwaiter_ (PromiseCore< void > &core)
	PromiseAwaiter_ (PromiseAwaiter_ &&)=delete
	PromiseAwaiter_ (const PromiseAwaiter_ &)=delete
PromiseAwaiter_ &	operator= (PromiseAwaiter_ &&)=delete
PromiseAwaiter_ &	operator= (const PromiseAwaiter_ &)=delete
bool	await_ready () const
bool	await_suspend (std::coroutine_handle<> handle) const
void	await_resume () const

Public Attributes
PromiseCore< void > &	core_

Detailed Description

Handles the actual suspension and resumption.

Constructor & Destructor Documentation

PromiseAwaiter_() [1/3]

uvco::Promise< void >::PromiseAwaiter_::PromiseAwaiter_ ( PromiseCore< void > &  core )

explicit

The core is shared among all copies of this Promise and holds the resumption handle to a waiting coroutine, as well as the ready state.

    : core_{core} {}

PromiseAwaiter_() [2/3]

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

delete

PromiseAwaiter_() [3/3]

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

delete

Member Function Documentation

await_ready()

bool uvco::Promise< void >::PromiseAwaiter_::await_ready

(

)

const

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

                                                     {
  return core_.ready_ || core_.exception_;
}

await_resume()

void uvco::Promise< void >::PromiseAwaiter_::await_resume

(

)

const

                                                      {
  if (core_.stale()) {
    throw UvcoException(
        "co_await called on previously finished promise (void)");
  }
  if (core_.exception_) {
    std::rethrow_exception(core_.exception_.value());
  }
  BOOST_ASSERT(core_.ready_);
}

await_suspend()

bool uvco::Promise< void >::PromiseAwaiter_::await_suspend

(

std::coroutine_handle<>

handle

)

const

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

                                        {
  BOOST_ASSERT(!core_.ready_ && !core_.exception_);
  BOOST_ASSERT_MSG(!core_.willResume(),
                   "promise is already being waited on!\n");
  core_.setHandle(handle);
  return true;
}

operator=() [1/2]

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

delete

operator=() [2/2]

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

delete

Member Data Documentation

core_

PromiseCore<void>& uvco::Promise< void >::PromiseAwaiter_::core_

---

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

• uvco/promise/promise.h
• uvco/promise/promise.cc