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

Public Member Functions
	FileOpAwaiter_ ()
	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
std::unique_ptr< uv_fs_t >	req_
std::coroutine_handle	handle_
std::optional< ssize_t >	result_ = std::nullopt

Constructor & Destructor Documentation

FileOpAwaiter_() [1/3]

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

inline

: req_{std::make_unique<uv_fs_t>()} {}

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

                    {
    if (!requestDataIsNull(req_.get())) {
      // A callback is pending and the FileOp is aborted. Clean up.
      resetRequestData(req_.get());
      // The onFileOpDone callback will clean up after us.
      uv_cancel((uv_req_t *)req_.release());
    } else {
      uv_fs_req_cleanup(req_.get());
    }
  }

Member Function Documentation

await_ready()

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

inlinenodiscardnoexcept

                                                  {
    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_);
    BOOST_ASSERT(!requestDataIsNull(req_.get()));
    resetRequestData(req_.get());
    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");
    BOOST_ASSERT(requestDataIsNull(req_.get()));
    setRequestData(req_.get(), this);
    handle_ = handle;
    return true;
  }

onFileOpDone()

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

inlinestaticprivate

                                         {
    auto *awaiter = getRequestDataOrNull<FileOpAwaiter_>(req);
    if (awaiter == nullptr || req->result == UV_ECANCELED) {
      // cancelled
      uv_fs_req_cleanup(req);
      delete req;
      return;
    }
    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 ( )

inlinenodiscard

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_) {
      Loop::enqueue(handle_);
      handle_ = nullptr;
    }
  }

uvCallback()

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

inlinestaticnodiscard

{ return onFileOpDone; }

Member Data Documentation

handle_

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

private

req_

std::unique_ptr<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