uvco::UnixStreamClient::ConnectAwaiter_ Struct Reference

Public Member Functions
	ConnectAwaiter_ (const ConnectAwaiter_ &)=delete
	ConnectAwaiter_ (ConnectAwaiter_ &&)=delete
ConnectAwaiter_ &	operator= (const ConnectAwaiter_ &)=delete
ConnectAwaiter_ &	operator= (ConnectAwaiter_ &&)=delete
	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 >	req_
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_() [1/3]

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

delete

ConnectAwaiter_() [2/3]

uvco::UnixStreamClient::ConnectAwaiter_::ConnectAwaiter_ ( ConnectAwaiter_ && )

delete

ConnectAwaiter_() [3/3]

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

explicit

    : req_{std::make_unique<uv_connect_t>()},
      pipe_{std::make_unique<uv_pipe_t>()} {
  uv_pipe_init(loop.uvloop(), pipe_.get(), 0);
  setRequestData(req_.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());
  }
  // Request object is freed by onConnect
}

Member Function Documentation

await_ready()

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

staticnodiscard

{ return false; }

await_resume()

UnixStream uvco::UnixStreamClient::ConnectAwaiter_::await_resume

(

)

                                                         {
  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;
  return true;
}

onConnect()

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

static

                                                                    {
  const std::unique_ptr<uv_connect_t> reqPtr{req};
  auto *awaiter = getRequestDataOrNull<ConnectAwaiter_>(reqPtr.get());
  if (awaiter == nullptr) {
    return;
  }
  awaiter->status_ = status;
  if (awaiter->handle_) {
    Loop::enqueue(awaiter->handle_);
    awaiter->handle_ = nullptr;
  }
}

operator=() [1/2]

ConnectAwaiter_ & uvco::UnixStreamClient::ConnectAwaiter_::operator= ( ConnectAwaiter_ && )

delete

operator=() [2/2]

ConnectAwaiter_ & uvco::UnixStreamClient::ConnectAwaiter_::operator= ( const ConnectAwaiter_ & )

delete

Member Data Documentation

handle_

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

pipe_

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

req_

std::unique_ptr<uv_connect_t> uvco::UnixStreamClient::ConnectAwaiter_::req_

status_

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

{};

---

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

• uvco/uds.cc