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::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}, host_{address.address()}, af_hint_{AF_UNSPEC},
      port_{address.port()} {}

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.

                                      {
  Resolver resolver{*loop_};
 
  AddressHandle address =
      co_await resolver.gai(host_, fmt::format("{}", port_), af_hint_);
 
  uv_connect_t req;
  ConnectAwaiter_ connect{};
  req.data = &connect;
 
  auto tcp = std::make_unique<uv_tcp_t>();
 
  uv_tcp_init(loop_->uvloop(), tcp.get());
  const uv_status connectStatus =
      uv_tcp_connect(&req, tcp.get(), address.sockaddr(), onConnect);
  if (connectStatus < 0) {
    // Clean up handle if connect failed.
    co_await closeHandle(tcp.get());
    throw UvcoException(connectStatus,
                        "TcpClient::connect() failed immediately");
  }
 
  const uv_status awaitStatus = co_await connect;
  if (awaitStatus < 0) {
    co_await closeHandle(tcp.get());
    throw UvcoException(awaitStatus, "TcpClient::connect() failed");
  }
 
  co_return TcpStream{std::move(tcp)};
}

onConnect()

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

staticprivate

                                                             {
  auto *connect = getRequestData<ConnectAwaiter_>(req);
  connect->onConnect(status);
}

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

---

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

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