Struct Connecting 

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

A WebSocket connection in the handshake phase.

Drive the handshake by calling poll() when the socket is ready. Returns Client<S> when complete.

Check wants_read() / wants_write() to determine which readiness event to wait for in your event loop.

Usage

use nexus_web::ws::{Connecting, ClientBuilder};

let tcp = TcpStream::connect("exchange.com:443")?;
tcp.set_nonblocking(true)?;
let mut connecting = ClientBuilder::new()
    .begin_connect(tcp, "wss://exchange.com/ws")?;

// In your event loop:
loop {
    // ... poll for socket readiness ...
    if let Some(ws) = connecting.poll()? {
        // Handshake complete — ws.recv() is now available
        break;
    }
}

Implementations

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

pub fn poll(&mut self) -> Result<Option<Client<S>>, Error>

Drive the handshake forward. Non-blocking.

Returns Ok(None) while in progress, Ok(Some(ws)) when the connection is ready and recv() can be called.

Call when the socket is readable or writable (check wants_read() / wants_write()).

On WouldBlock, returns Ok(None) — call again when the socket is ready.

pub fn wants_write(&self) -> bool

Whether the handshake needs to write to the socket.

pub fn wants_read(&self) -> bool

Whether the handshake needs to read from the socket.

pub fn stream(&self) -> &S

Access the underlying stream (for mio registration).

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

Mutable access to the underlying stream.

Trait Implementations

impl<S> Drop for Connecting<S>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.