uvco::UnixStreamClient::ConnectAwaiter_ Struct Reference

Public Member Functions
	ConnectAwaiter_ (const Loop &loop, std::string_view path)
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
uv_connect_t	request_ {}
std::unique_ptr< uv_pipe_t >	pipe_
std::string_view	path_
std::optional< std::coroutine_handle<> >	handle_
std::optional< 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, std::string_view  path  )

explicit

    : pipe_{std::make_unique<uv_pipe_t>()}, path_{path} {
  uv_pipe_init(loop.uvloop(), pipe_.get(), 0);
}

Member Function Documentation

await_ready()

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

static

{ return false; }

await_resume()

UnixStream uvco::UnixStreamClient::ConnectAwaiter_::await_resume

(

)

                                                         {
  BOOST_ASSERT(status_);
  if (*status_ != 0) {
    throw UvcoException{*status_, "UnixStreamClient failed to connect"};
  }
  status_.reset();
  handle_.reset();
  return UnixStream{std::move(pipe_)};
}

await_suspend()

bool uvco::UnixStreamClient::ConnectAwaiter_::await_suspend

(

std::coroutine_handle<>

handle

)

                                  {
  handle_ = handle;
  request_.data = this;
 
#if UV_VERSION_MAJOR == 1 && UV_VERSION_MINOR >= 46
  const uv_status connectStatus = uv_pipe_connect2(
      &request_, pipe_.get(), path_.data(), path_.size(), 0, onConnect);
  if (connectStatus != 0) {
    status_ = connectStatus;
    if (handle_) {
      Loop::enqueue(*handle_);
      handle_.reset();
    }
  }
#else
  uv_pipe_connect(&request_, pipe_.get(), path_.data(), onConnect);
#endif
 
  return true;
}

onConnect()

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

static

                                                                    {
  auto *awaiter = getRequestData<ConnectAwaiter_>(req);
  awaiter->status_ = status;
  if (awaiter->handle_) {
    Loop::enqueue(awaiter->handle_.value());
    awaiter->handle_.reset();
  }
}

Member Data Documentation

handle_

std::optional<std::coroutine_handle<> > uvco::UnixStreamClient::ConnectAwaiter_::handle_

path_

std::string_view uvco::UnixStreamClient::ConnectAwaiter_::path_

pipe_

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

request_

uv_connect_t uvco::UnixStreamClient::ConnectAwaiter_::request_ {}

{};

status_

std::optional<uv_status> uvco::UnixStreamClient::ConnectAwaiter_::status_

---

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

• uvco/uds.h
• uvco/uds.cc