uvco::TcpClient Class Reference

A client for connecting to a TCP peer. More...

#include <tcp.h>

Collaboration diagram for uvco::TcpClient:

Classes
struct	ConnectAwaiter_

Public Member Functions
	TcpClient (const Loop &loop, std::string target_host_address, uint16_t target_host_port, int af_hint=AF_UNSPEC)
	TcpClient (const Loop &loop, AddressHandle address)
	Create a TCP client connecting to the given address.
	TcpClient (TcpClient &&other) noexcept
	TcpClient (const TcpClient &)=delete
TcpClient &	operator= (TcpClient &&other) noexcept
TcpClient &	operator= (const TcpClient &)=delete
	~TcpClient ()=default
Promise< TcpStream >	connect ()

Static Private Member Functions
static void	onConnect (uv_connect_t *req, uv_status status)

Private Attributes
const Loop *	loop_
std::optional< AddressHandle >	resolvedAddress_
std::string	host_
int	af_hint_ {}
uint16_t	port_ {}

Detailed Description

A client for connecting to a TCP peer.

Constructor & Destructor Documentation

TcpClient() [1/4]

uvco::TcpClient::TcpClient	(	const Loop &	loop,
		std::string	target_host_address,
		uint16_t	target_host_port,
		int	af_hint = AF_UNSPEC )

Create a client; call connect() to obtain a TcpStream. Address can be given as domain name, IP, etc.

    : loop_{&loop}, host_{std::move(target_host_address)}, af_hint_{af_hint},
      port_{target_host_port} {}

TcpClient() [2/4]

uvco::TcpClient::TcpClient	(	const Loop &	loop,
		AddressHandle	address )

Create a TCP client connecting to the given address.

    : loop_{&loop}, resolvedAddress_{address} {}

TcpClient() [3/4]

uvco::TcpClient::TcpClient ( TcpClient && other )

noexcept

    : loop_{other.loop_}, host_{std::move(other.host_)},
      af_hint_{other.af_hint_}, port_{other.port_} {}

TcpClient() [4/4]

uvco::TcpClient::TcpClient ( const TcpClient & )

delete

~TcpClient()

uvco::TcpClient::~TcpClient ( )

default

Member Function Documentation

connect()

Promise< TcpStream > uvco::TcpClient::connect

(

)

Connect to the peer specified in the constructor. The TcpClient object is meaningless after this call and can be destroyed.

                                      {
  AddressHandle address;
  if (resolvedAddress_.has_value()) {
    address = resolvedAddress_.value();
  } else {
    Resolver resolver{*loop_};
    address = co_await resolver.gai(host_, port_, af_hint_);
  }
 
  ConnectAwaiter_ awaiter;
  const OnExit onExit{[&awaiter, req = awaiter.req_.get()] {
    if (awaiter.handle_ != nullptr) {
      resetRequestData(req);
    }
  }};
 
  const uv_status initStatus =
      uv_tcp_init(loop_->uvloop(), awaiter.socket_.get());
  if (initStatus < 0) {
    throw UvcoException(initStatus,
                        "TcpClient::connect() uv_tcp_init() failed");
  }
 
  // onConnect callback gets ownership of req_.
  const uv_status connectStatus =
      uv_tcp_connect(awaiter.req_.release(), awaiter.socket_.get(),
                     address.sockaddr(), onConnect);
  if (connectStatus < 0) {
    // Clean up handle if connect failed.
    throw UvcoException(connectStatus,
                        "TcpClient::connect() failed immediately");
  }
 
  std::optional<UvcoException> maybeError;
  try {
    co_return (co_await awaiter);
  } catch (const UvcoException &e) {
    maybeError = e;
  }
 
  std::unique_ptr<uv_tcp_t> tcpSocket = std::move(awaiter.socket_);
  closeHandle(tcpSocket.release(), uvCloseReset);
  BOOST_ASSERT(maybeError.has_value());
  throw std::move(maybeError.value());
}

onConnect()

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

staticprivate

                                                             {
  std::unique_ptr<uv_connect_t> reqPtr{req};
  auto *awaiter = getRequestDataOrNull<ConnectAwaiter_>(reqPtr.get());
  if (awaiter == nullptr) {
    return;
  }
  awaiter->onConnect(status);
  resetRequestData(reqPtr.get());
}

operator=() [1/2]

TcpClient & uvco::TcpClient::operator= ( const TcpClient & )

delete

operator=() [2/2]

TcpClient & uvco::TcpClient::operator= ( TcpClient && other )

noexcept

                                                          {
  loop_ = other.loop_;
  host_ = std::move(other.host_);
  port_ = other.port_;
  return *this;
}

Member Data Documentation

af_hint_

int uvco::TcpClient::af_hint_ {}

private

{};

host_

std::string uvco::TcpClient::host_

private

loop_

const Loop* uvco::TcpClient::loop_

private

port_

uint16_t uvco::TcpClient::port_ {}

private

{};

resolvedAddress_

std::optional<AddressHandle> uvco::TcpClient::resolvedAddress_

private

---

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

• uvco/tcp.h
• uvco/tcp.cc