Struct TcpWriter 

pub struct TcpWriter<'a> { /* private fields */ }

The writer half of a TCP socket.

Implementations

impl<'a> TcpWriter<'a>

pub fn wait_write_ready(&self) -> impl Future<Output = ()> + '_

Wait until the socket becomes writable.

A socket becomes writable when the transmit half of the full-duplex connection is open (see may_send()), and the transmit buffer is not full.

This is the equivalent of write, without sending any data.

pub fn write<'s>( &'s mut self, buf: &'s [u8], ) -> impl Future<Output = Result<usize, Error>> + 's

Write data to the socket.

Returns how many bytes were written, or an error. If the socket is not ready to accept data, it waits until it is.

pub fn try_write(&mut self, buf: &[u8]) -> Result<usize, TryError<Error>>

Write data to the socket.

This method will not wait for the buffer to become free.

If the socket’s send buffer is full, this method will return Err(TryError::WouldBlock).

pub fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + '_

Flushes the written data to the socket.

This waits until all data has been sent, and ACKed by the remote host. For a connection closed with abort() it will wait for the TCP RST packet to be sent.

pub fn try_flush(&mut self) -> Result<(), TryError<Error>>

Try to flush the socket.

This method will check if the socket is flushed, and if not, return Err(TryError::WouldBlock).

pub async fn write_with<F, R>(&mut self, f: F) -> Result<R, Error>

where F: FnOnce(&mut [u8]) -> (usize, R),

Call f with the largest contiguous slice of octets in the transmit buffer, and enqueue the amount of elements returned by f.

If the socket is not ready to accept data, it waits until it is.

pub fn try_write_with<F, R>(&mut self, f: F) -> Result<R, TryError<Error>>

where F: FnOnce(&mut [u8]) -> (usize, R),

Call f with the largest contiguous slice of octets in the transmit buffer, and enqueue the amount of elements returned by f.

This method will not wait for the buffer to become free.

If the socket’s send buffer is full, this method will return Err(TryError::WouldBlock).

pub fn send_capacity(&self) -> usize

Return the maximum number of bytes inside the transmit buffer.

pub fn send_queue(&self) -> usize

Return the amount of octets queued in the transmit buffer.

pub fn may_send(&self) -> bool

Return whether the transmit half of the full-duplex connection is open.

This function returns true if it’s possible to send data and have it arrive to the remote endpoint. However, it does not make any guarantees about the state of the transmit buffer, and even if it returns true, write may not be able to enqueue any octets.

In terms of the TCP state machine, the socket must be in the ESTABLISHED or CLOSE-WAIT state.

pub fn can_send(&self) -> bool

Check whether the transmit half of the full-duplex connection is open (see may_send), and the transmit buffer is not full.

pub fn may_recv(&self) -> bool

Return whether the receive half of the full-duplex connection is open. This function returns true if it’s possible for the corresponding TcpWriter to receive data from the remote endpoint. It will return true as long as the remote endpoint has not closed the connection.

Trait Implementations

impl<'d> ErrorType for TcpWriter<'d>

type Error = Error

Error type of all the IO operations on this type.

impl<'d> Write for TcpWriter<'d>

async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.

impl<'d> WriteReady for TcpWriter<'d>

fn write_ready(&mut self) -> Result<bool, Self::Error>

Get whether the writer is ready for immediately writing.