uvco::UnixStreamClient::ConnectAwaiter_ Struct Reference

Public Member Functions
	ConnectAwaiter_ (const Loop &loop)
	~ConnectAwaiter_ ()
bool	await_suspend (std::coroutine_handle<> handle)
UnixStream	await_resume ()

Static Public Member Functions
static void	onConnect (uv_connect_t *req, uv_status status)
static bool	await_ready ()

Public Attributes
std::unique_ptr< uv_connect_t >	request_ {}
std::unique_ptr< uv_pipe_t >	pipe_
std::coroutine_handle	handle_
uv_status	status_ {}

Detailed Description

An awaiter class used to wait for a connection to be established.

Implementation note: almost the entire mechanics of connecting is handled by the awaiter. The connect() method is just a thin wrapper around the awaiter; the awaiter's methods also throw exceptions. This is different than e.g. in the TcpClient class.

Constructor & Destructor Documentation

ConnectAwaiter_()

uvco::UnixStreamClient::ConnectAwaiter_::ConnectAwaiter_ ( const Loop & loop )

explicit

    : request_{std::make_unique<uv_connect_t>()},
      pipe_{std::make_unique<uv_pipe_t>()} {
  uv_pipe_init(loop.uvloop(), pipe_.get(), 0);
  setRequestData(request_.get(), this);
}

~ConnectAwaiter_()

uvco::UnixStreamClient::ConnectAwaiter_::~ConnectAwaiter_

(

)

                                                  {
  // request data is reset by await_resume(), so if it's non-null, the
  // connection attempt was cancelled and we need to clean up.
  if (pipe_ != nullptr) {
    closeHandle(pipe_.release());
  }
  if (!requestDataIsNull(request_.get())) {
    resetRequestData(request_.get());
    uv_cancel((uv_req_t *)request_.release());
  }
}

Member Function Documentation

await_ready()

bool uvco::UnixStreamClient::ConnectAwaiter_::await_ready ( )

staticnodiscard

{ return false; }

await_resume()

UnixStream uvco::UnixStreamClient::ConnectAwaiter_::await_resume

(

)

                                                         {
  resetRequestData(request_.get());
  if (status_ != 0) {
    throw UvcoException{status_, "UnixStreamClient failed to connect"};
  }
  handle_ = nullptr;
  return UnixStream{std::move(pipe_)};
}

await_suspend()

bool uvco::UnixStreamClient::ConnectAwaiter_::await_suspend

(

std::coroutine_handle<>

handle

)

                                  {
  BOOST_ASSERT(handle_ == nullptr);
  handle_ = handle;
  setRequestData(request_.get(), this);
  request_->data = this;
  return true;
}

onConnect()

void uvco::UnixStreamClient::ConnectAwaiter_::onConnect ( uv_connect_t * req, uv_status status )

static

                                                                    {
  auto *awaiter = getRequestDataOrNull<ConnectAwaiter_>(req);
  if (awaiter == nullptr) {
    delete req;
    return;
  }
  if (status == UV_ECANCELED) {
    return;
  }
  awaiter->status_ = status;
  if (awaiter->handle_) {
    Loop::enqueue(awaiter->handle_);
    awaiter->handle_ = nullptr;
  }
}

Member Data Documentation

handle_

std::coroutine_handle uvco::UnixStreamClient::ConnectAwaiter_::handle_

pipe_

std::unique_ptr<uv_pipe_t> uvco::UnixStreamClient::ConnectAwaiter_::pipe_

request_

std::unique_ptr<uv_connect_t> uvco::UnixStreamClient::ConnectAwaiter_::request_ {}

{};

status_

uv_status uvco::UnixStreamClient::ConnectAwaiter_::status_ {}

{};

---

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

• uvco/uds.cc