uvco::PromiseCore< T > Class Template Reference

#include <promise_core.h>

Inheritance diagram for uvco::PromiseCore< T >:

Public Member Functions
	PromiseCore ()=default
	PromiseCore (const PromiseCore &)=delete
	PromiseCore (PromiseCore &&)=delete
PromiseCore &	operator= (const PromiseCore &)=delete
PromiseCore &	operator= (PromiseCore &&)=delete
virtual	~PromiseCore ()=default
	PromiseCore (T &&value)
virtual void	setHandle (std::coroutine_handle<> handle)
	Set the coroutine to be resumed once a result is ready.
void	setRunning (std::coroutine_handle<> handle)
	Used by Coroutine<T> to set the producing coroutine handle.
void	resetHandle ()
bool	isAwaited ()
	Checks if a coroutine is waiting on a promise belonging to this core.
bool	ready () const
	Checks if a value is present in the slot.
bool	stale () const
void	resume ()
void	destroyCoroutine ()
void	except (const std::exception_ptr &exc)

Public Attributes
std::optional< std::variant< T, std::exception_ptr > >	slot
	The slot contains the result once obtained.

Protected Attributes
std::coroutine_handle	coroutine_
std::coroutine_handle	waitingHandle_
PromiseState	state_ = PromiseState::init

Detailed Description

template<typename T>
class uvco::PromiseCore< T >

A PromiseCore is part of the Coroutine<T> frame; a reference to it is held by the Promise referring to the coroutine.

Constructor & Destructor Documentation

PromiseCore() [1/4]

template<typename T>

uvco::PromiseCore< T >::PromiseCore ( )

default

PromiseCore() [2/4]

template<typename T>

uvco::PromiseCore< T >::PromiseCore ( const PromiseCore< T > & )

delete

PromiseCore() [3/4]

template<typename T>

uvco::PromiseCore< T >::PromiseCore ( PromiseCore< T > && )

delete

~PromiseCore()

template<typename T>

virtual uvco::PromiseCore< T >::~PromiseCore ( )

virtualdefault

PromiseCore() [4/4]

template<typename T>

uvco::PromiseCore< T >::PromiseCore ( T && value )

inlineexplicit

      : slot{std::move(value)}, state_{PromiseState::finished} {}

Member Function Documentation

destroyCoroutine()

template<typename T>

void uvco::PromiseCore< T >::destroyCoroutine ( )

inline

                          {
    if (coroutine_) {
      Loop::cancel(coroutine_);
      coroutine_.destroy();
    }
  }

except()

template<typename T>

void uvco::PromiseCore< T >::except ( const std::exception_ptr & exc )

inline

{ slot = exc; }

isAwaited()

template<typename T>

bool uvco::PromiseCore< T >::isAwaited ( )

inline

Checks if a coroutine is waiting on a promise belonging to this core.

{ return waitingHandle_ != nullptr; }

operator=() [1/2]

template<typename T>

PromiseCore & uvco::PromiseCore< T >::operator= ( const PromiseCore< T > & )

delete

operator=() [2/2]

template<typename T>

PromiseCore & uvco::PromiseCore< T >::operator= ( PromiseCore< T > && )

delete

ready()

template<typename T>

bool uvco::PromiseCore< T >::ready ( ) const

inlinenodiscard

Checks if a value is present in the slot.

{ return slot.has_value(); }

resetHandle()

template<typename T>

void uvco::PromiseCore< T >::resetHandle ( )

inline

Reset the handle, so that the coroutine is not resumed anymore. This is required for SelectSet.

                     {
    BOOST_ASSERT((state_ == PromiseState::waitedOn && waitingHandle_) ||
                 (state_ == PromiseState::finished && !waitingHandle_) ||
                 (state_ == PromiseState::init && !waitingHandle_));
    if (state_ == PromiseState::waitedOn) {
      waitingHandle_ = nullptr;
      state_ = PromiseState::init;
    }
  }

resume()

template<typename T>

void uvco::PromiseCore< T >::resume ( )

inline

Resume a suspended coroutine waiting on the associated coroutine by enqueuing it in the global event loop.

A promise core can only be resumed once.

                {
    if (waitingHandle_) {
      BOOST_ASSERT(state_ == PromiseState::waitedOn);
      const std::coroutine_handle<> resume = waitingHandle_;
      waitingHandle_ = nullptr;
      Loop::enqueue(resume);
    } else {
      // This occurs if no co_await has occured until resume. Either the
      // promise was not co_awaited, or the producing coroutine immediately
      // returned a value. (await_ready() == true)
    }
    state_ = PromiseState::finished;
  }

setHandle()

template<typename T>

void uvco::PromiseCore< T >::setHandle ( std::coroutine_handle<> handle )

inlinevirtual

Set the coroutine to be resumed once a result is ready.

Reimplemented in uvco::MultiPromiseCore< T >.

                                                       {
    if (state_ != PromiseState::init) {
      throw UvcoException("PromiseCore is already awaited or has finished");
    }
    waitingHandle_ = handle;
    state_ = PromiseState::waitedOn;
  }

setRunning()

template<typename T>

void uvco::PromiseCore< T >::setRunning ( std::coroutine_handle<> handle )

inline

Used by Coroutine<T> to set the producing coroutine handle.

                                                {
    BOOST_ASSERT(state_ == PromiseState::init);
    coroutine_ = handle;
  }

stale()

template<typename T>

bool uvco::PromiseCore< T >::stale ( ) const

inlinenodiscard

Returns true if the promise has completed, and its results have been fetched.

                                   {
    return state_ == PromiseState::finished && !ready();
  }

Member Data Documentation

coroutine_

template<typename T>

std::coroutine_handle uvco::PromiseCore< T >::coroutine_

protected

Set to the coroutine producing this promise. Used to destroy it after completion or when the associated Promise is dropped.

slot

template<typename T>

std::optional<std::variant<T, std::exception_ptr> > uvco::PromiseCore< T >::slot

The slot contains the result once obtained.

state_

template<typename T>

PromiseState uvco::PromiseCore< T >::state_ = PromiseState::init

protected

waitingHandle_

template<typename T>

std::coroutine_handle uvco::PromiseCore< T >::waitingHandle_

protected

Set to the coroutine awaiting this promise if state_ == awaitedOn. May be nullptr.

---

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

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