Struct Client 

pub struct Client<S> { /* private fields */ }

WebSocket stream — owns a socket, reader, writer, and buffers.

Handles both plain ws:// and encrypted wss:// connections. The URL scheme determines whether TLS is used — no separate type needed.

Usage

use nexus_web::ws::Client;
use nexus_web::tls::TlsConfig;

// Plain WebSocket
let mut ws = Client::builder().connect("ws://localhost:8080/ws")?;

// TLS WebSocket (requires 'tls' feature)
let tls = TlsConfig::new()?;
let mut ws = Client::builder().tls(&tls).connect("wss://exchange.com/ws")?;

// Same API for both:
ws.send_text("Hello!")?;
while let Some(msg) = ws.recv()? {
    // ...
}

Implementations

impl Client<TcpStream>

pub fn builder() -> ClientBuilder

Create a builder for configuring buffer sizes, socket options, and TLS.

impl<S> Client<S>

pub fn from_parts(stream: S, reader: FrameReader, writer: FrameWriter) -> Self

Create from pre-existing parts. For testing or custom handshakes.

pub fn is_poisoned(&self) -> bool

Whether the stream is poisoned (I/O error occurred during send).

A poisoned stream should not be reused — the connection may be in an indeterminate state (partial frame written).

pub fn stream(&self) -> &S

Access the underlying stream.

pub fn stream_mut(&mut self) -> &mut S

Mutable access to the underlying stream.

pub fn reader(&self) -> &FrameReader

Access the FrameReader.

pub fn frame_writer(&self) -> &FrameWriter

Access the FrameWriter.

impl<S: Read + Write> Client<S>

pub fn connect_with(stream: S, url: &str) -> Result<Self, Error>

Connect using a pre-connected socket with default configuration.

IPv6 addresses must use bracket notation: ws://[::1]:8080/path.

pub fn accept(stream: S) -> Result<Self, Error>

Accept an incoming WebSocket connection (server-side).

pub fn recv(&mut self) -> Result<Option<Message<'_>>, Error>

Receive the next message. Reads from the socket as needed.

Returns Ok(None) on EOF, buffer full, or WouldBlock (non-blocking sockets).

pub fn send_text(&mut self, text: &str) -> Result<(), Error>

Send a text message.

pub fn send_binary(&mut self, data: &[u8]) -> Result<(), Error>

Send a binary message.

pub fn send_ping(&mut self, data: &[u8]) -> Result<(), Error>

Send a ping.

pub fn send_pong(&mut self, data: &[u8]) -> Result<(), Error>

Send a pong.

pub fn close(&mut self, code: CloseCode, reason: &str) -> Result<(), Error>

Initiate close handshake.