Struct ClientIo 

pub(super) struct ClientIo<T> {
    io: T,
    discard: Arc<DiscardState>,
    left: usize,
    ended: bool,
    written: Activity,
}

The connection of a WebSocket client, whose input can get dropped instead of read, see Discard.

Fields

io: T

discard: Arc<DiscardState>

left: usize

How much input may still get dropped.

ended: bool

Whether the client ended its side of the connection.

written: Activity

Touched whenever a part of what the server sends went out.

Implementations

impl<T> ClientIo<T>

const DISCARD_READS: usize = 16

How many reads of dropped input one poll does at most, so that a client which keeps sending does not hold the thread.

pub(super) fn new(io: T) -> Self

Wrap the connection of a client.

pub(super) fn written(&self) -> Activity

Touched whenever a part of what the server sends went out, which tells that the client still takes it, see Activity::until_stalled.

pub(super) fn discarder(&self) -> Discard

Drops the input of the connection.

fn discarding(&self) -> bool

fn drain(&mut self)

Drop the input from now on, with a budget of its own for the end of the WebSocket, see drain.

impl<T: AsyncRead + Unpin> ClientIo<T>

fn poll_discard(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

Read and drop the input until the connection ended, which it is ready for.

fn poll_writing<R>( &mut self, cx: &mut Context<'_>, write: impl FnOnce(Pin<&mut T>, &mut Context<'_>) -> Poll<R>, ) -> Poll<R>

Run a write, after dropping the input if it gets dropped. The read leaves the waker of the write with the connection, so that input wakes a write which waits for the client, also one which started before the input got dropped.

impl<T> ClientIo<T>

fn wrote(&self, poll: Poll<Result<usize>>) -> Poll<Result<usize>>

Touch ClientIo::written for a write which wrote something.

Trait Implementations

impl<T: AsyncRead + Unpin> AsyncRead for ClientIo<T>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<T: AsyncRead + AsyncWrite + Unpin> AsyncWrite for ClientIo<T>

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.