Struct HostEndpoint 

pub struct HostEndpoint { /* private fields */ }

A TCP endpoint resolved afresh for each connect or bind. Connection attempts follow resolver order; binding creates a listener for every resolved address. There is no cache or background resolver task.

Implementations

impl HostEndpoint

pub fn new(hostname: impl Into<String>, port: u16) -> Self

Describe a TCP hostname and numeric port. Pass an unbracketed hostname or IP literal without a port.

pub const fn wildcard(port: u16) -> Self

Describe all local interfaces for binding. When connecting, an absent hostname selects loopback addresses according to the resolver’s contract.

pub fn with_domain(self, domain: SocketDomain) -> Self

Restrict resolution to the selected IP family. By default both families are eligible.

pub fn hostname(&self) -> Option<&str>

The configured hostname, or None for wildcard binding and loopback connecting.

pub const fn port(&self) -> u16

The configured port.

pub async fn resolve<S: AddressResolution + ?Sized>( &self, scheduler: &S, passive: bool, cancellation: &Cancellation, ) -> OperationResult<Vec<AddressEndpoint>>

Resolve to numeric TCP endpoints, preserving order and duplicates. passive selects wildcard addresses for an absent hostname; otherwise an absent hostname selects loopback. Empty results are preserved here and rejected by connect/bind.

Trait Implementations

impl<S> BindEndpoint<S> for HostEndpoint

where S: AddressResolution + SocketOpen + SocketBind + SocketListen + SocketClose + ?Sized,

type Listener = <S as SocketOperation>::Socket

One bound listener, owned by the caller on success. Its representation belongs to the endpoint implementation.

async fn bind( &self, scheduler: &S, options: BindOptions, cancellation: &Cancellation, ) -> OperationResult<Vec<S::Socket>>

Bind and start listening on every address. Success returns a nonempty collection; failure transfers no listeners to the caller. Futures are lazy. Await completion after cooperative cancellation to finish asynchronous rollback; dropping a pending future provides ordinary destruction only.

impl Clone for HostEndpoint

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> ConnectEndpoint<S> for HostEndpoint

where S: AddressResolution + SocketOpen + SocketConnect + SocketClose + ?Sized,

type Connection = <S as SocketOperation>::Socket

The established transport, owned by the caller on success.

async fn connect( &self, scheduler: &S, cancellation: &Cancellation, ) -> OperationResult<S::Socket>

Establish one connection. Futures are lazy. Await completion after requesting cooperative cancellation so implementation-owned asynchronous cleanup can finish. Dropping a future abandons it and provides ordinary resource destruction, not an asynchronous cleanup guarantee.

impl Debug for HostEndpoint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for HostEndpoint

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for HostEndpoint

impl PartialEq for HostEndpoint

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for HostEndpoint