uvco::PromiseCore< void > Class Reference

#include <promise_core.h>

Inheritance diagram for uvco::PromiseCore< void >:

Collaboration diagram for uvco::PromiseCore< void >:

Public Member Functions
	PromiseCore ()=default
	PromiseCore (const PromiseCore &)=delete
	PromiseCore (PromiseCore &&)=delete
PromiseCore< void > &	operator= (const PromiseCore &)=delete
PromiseCore< void > &	operator= (PromiseCore &&)=delete
	~PromiseCore () override
void	cancel ()
	See PromiseCore::cancel.
void	setHandle (std::coroutine_handle<> handle)
	See PromiseCore::set_resume.
void	resetHandle ()
	See PromiseCore::resetHandle.
bool	willResume () const
	See PromiseCore::willResume.
bool	ready () const
	See PromiseCore::ready.
bool	stale () const
	See PromiseCore::stale.
void	resume ()
	See PromiseCore::resume.
void	except (std::exception_ptr exc)
	See PromiseCore::except.
Public Member Functions inherited from uvco::RefCounted< PromiseCore< void > >
	RefCounted (const RefCounted &other)=default
	RefCounted (RefCounted &&other) noexcept
RefCounted &	operator= (const RefCounted &other)=default
RefCounted &	operator= (RefCounted &&other) noexcept
virtual	~RefCounted ()=default
virtual PromiseCore< void > *	addRef ()
virtual void	delRef ()

Public Attributes
bool	ready_ = false
std::optional< std::exception_ptr >	exception_
	Contains the exception if thrown.

Private Attributes
std::optional< std::coroutine_handle<> >	handle_
PromiseState	state_ = PromiseState::init

Additional Inherited Members
Protected Member Functions inherited from uvco::RefCounted< PromiseCore< void > >
	RefCounted ()=default

Detailed Description

A void PromiseCore works like a normal PromiseCore, but with the specialization of not transferring values - only control is switched from the yielding to the awaiting coroutine.

Constructor & Destructor Documentation

PromiseCore() [1/3]

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

default

PromiseCore() [2/3]

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

delete

PromiseCore() [3/3]

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

delete

~PromiseCore()

uvco::PromiseCore< void >::~PromiseCore ( )

override

                                {
  BOOST_ASSERT(state_ != PromiseState::resuming);
  if (state_ == PromiseState::init) {
    fmt::print(stderr, "void Promise not finished\n");
  }
  if (handle_) {
    fmt::print(stderr, "resumable coroutine destroyed\n");
    handle_->destroy();
  }
}

Member Function Documentation

cancel()

void uvco::PromiseCore< void >::cancel

(

)

See PromiseCore::cancel.

                               {
  if (state_ == PromiseState::waitedOn) {
    BOOST_ASSERT(!exception_);
    if (!exception_) {
      exception_ = std::make_exception_ptr(
          UvcoException(UV_ECANCELED, "Promise cancelled"));
    }
    resume();
  }
}

except()

void uvco::PromiseCore< void >::except

(

std::exception_ptr

exc

)

See PromiseCore::except.

                                                   {
  BOOST_ASSERT(state_ == PromiseState::init ||
               state_ == PromiseState::waitedOn);
  exception_ = std::move(exc);
  ready_ = true;
}

operator=() [1/2]

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

delete

operator=() [2/2]

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

delete

ready()

bool uvco::PromiseCore< void >::ready

(

)

const

See PromiseCore::ready.

{ return exception_ || ready_; }

resetHandle()

void uvco::PromiseCore< void >::resetHandle

(

)

See PromiseCore::resetHandle.

                                    {
  BOOST_ASSERT((state_ == PromiseState::waitedOn && handle_) ||
               (state_ == PromiseState::finished && !handle_));
  handle_.reset();
  if (state_ == PromiseState::waitedOn) {
    state_ = PromiseState::init;
  }
}

resume()

void uvco::PromiseCore< void >::resume

(

)

See PromiseCore::resume.

                               {
  if (handle_) {
    BOOST_ASSERT(state_ == PromiseState::waitedOn);
    state_ = PromiseState::resuming;
    auto resumeHandle = *handle_;
    handle_.reset();
    Loop::enqueue(resumeHandle);
  } else {
    // If a coroutine returned immediately, or nobody is co_awaiting the result.
  }
  state_ = PromiseState::finished;
}

setHandle()

void uvco::PromiseCore< void >::setHandle

(

std::coroutine_handle<>

handle

)

See PromiseCore::set_resume.

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

stale()

bool uvco::PromiseCore< void >::stale

(

)

const

See PromiseCore::stale.

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

willResume()

bool uvco::PromiseCore< void >::willResume

(

)

const

See PromiseCore::willResume.

{ return handle_.has_value(); }

Member Data Documentation

exception_

std::optional<std::exception_ptr> uvco::PromiseCore< void >::exception_

Contains the exception if thrown.

handle_

std::optional<std::coroutine_handle<> > uvco::PromiseCore< void >::handle_

private

ready_

bool uvco::PromiseCore< void >::ready_ = false

In a void promise, we only track if the coroutine has finished, because it doesn't return anything.

state_

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

private

---

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

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