uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_ Class Reference

Public Member Functions
	FileOpAwaiter_ ()=default
	FileOpAwaiter_ (const FileOpAwaiter_ &)=delete
	FileOpAwaiter_ (FileOpAwaiter_ &&)=delete
FileOpAwaiter_ &	operator= (const FileOpAwaiter_ &)=delete
FileOpAwaiter_ &	operator= (FileOpAwaiter_ &&)=delete
	~FileOpAwaiter_ ()
uv_fs_t &	req ()
	Obtain the uv_fs_t struct to fill in before starting the operation.
bool	await_ready () const noexcept
bool	await_suspend (std::coroutine_handle<> handle)
void	await_resume ()

Static Public Member Functions
static uv_fs_cb	uvCallback ()

Private Member Functions
void	schedule ()

Static Private Member Functions
static void	onFileOpDone (uv_fs_t *req)

Private Attributes
uv_fs_t	req_ = {}
std::optional< std::coroutine_handle<> >	handle_
std::optional< ssize_t >	result_ = std::nullopt

Constructor & Destructor Documentation

FileOpAwaiter_() [1/3]

uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::FileOpAwaiter_ ( )

default

FileOpAwaiter_() [2/3]

uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::FileOpAwaiter_ ( const FileOpAwaiter_ &  )

delete

FileOpAwaiter_() [3/3]

uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::FileOpAwaiter_ ( FileOpAwaiter_ &&  )

delete

~FileOpAwaiter_()

uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::~FileOpAwaiter_ ( )

inline

{ uv_fs_req_cleanup(&req_); }

Member Function Documentation

await_ready()

bool uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::await_ready ( ) const

inlinenoexcept

                                                  {
    return result_.has_value();
  }

await_resume()

void uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::await_resume ( )

inline

The callback is guaranteed to have been called once the awaiting coroutine is resumed.

                      {
    BOOST_ASSERT(result_);
    if (result_ && result_.value() < 0) {
      throw UvcoException(static_cast<uv_status>(result_.value()),
                          "file operation failed");
    } else if (!result_) {
      throw UvcoException(UV_EAGAIN,
                          "file operation not yet finished (this is a bug)");
    }
  }

await_suspend()

bool uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::await_suspend ( std::coroutine_handle<>  handle )

inline

                                                   {
    BOOST_ASSERT(!result_);
    BOOST_ASSERT_MSG(!handle_, "FileOpAwaiter_ can only be awaited once");
    setRequestData(&req_, this);
    handle_ = handle;
    return true;
  }

onFileOpDone()

static void uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::onFileOpDone ( uv_fs_t *  req )

inlinestaticprivate

                                         {
    auto *awaiter = getRequestData<FileOpAwaiter_>(req);
    awaiter->result_ = req->result;
    awaiter->schedule();
  }

operator=() [1/2]

FileOpAwaiter_ & uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::operator= ( const FileOpAwaiter_ &  )

delete

operator=() [2/2]

FileOpAwaiter_ & uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::operator= ( FileOpAwaiter_ &&  )

delete

req()

uv_fs_t & uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::req ( )

inline

Obtain the uv_fs_t struct to fill in before starting the operation.

{ return req_; }

schedule()

void uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::schedule ( )

inlineprivate

                  {
    if (handle_) {
      const auto handle = handle_.value();
      handle_ = std::nullopt;
      Loop::enqueue(handle);
    }
  }

uvCallback()

static uv_fs_cb uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::uvCallback ( )

inlinestatic

{ return onFileOpDone; }

Member Data Documentation

handle_

std::optional<std::coroutine_handle<> > uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::handle_

private

req_

uv_fs_t uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::req_ = {}

private

{};

result_

std::optional<ssize_t> uvco::anonymous_namespace{fs.cc}::FileOpAwaiter_::result_ = std::nullopt

private

---

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

• uvco/fs.cc