Struct TcpReader

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

Available on crate feature tcp only.

The reader half of a TCP socket.

Implementations

impl<'a> TcpReader<'a>

pub fn wait_read_ready(&self) -> impl Future<Output = ()>

Wait until the socket becomes readable.

A socket becomes readable when the receive half of the full-duplex connection is open (see may_recv()), and there is some pending data in the receive buffer.

This is the equivalent of read, without buffering any data.

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

Read data from the socket.

Returns how many bytes were read, or an error. If no data is available, it waits until there is at least one byte available.

Note

A return value of Ok(0) means that we have read all data and the remote side has closed our receive half of the socket. The remote can no longer send bytes.

The send half of the socket is still open. If you want to reconnect using the socket you split this reader off the send half needs to be closed using abort().

pub async fn read_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 receive buffer, and dequeue the amount of elements returned by f.

If no data is available, it waits until there is at least one byte available.

pub fn recv_capacity(&self) -> usize

Return the maximum number of bytes inside the transmit buffer.

pub fn recv_queue(&self) -> usize

Return the amount of octets queued in the receive buffer. This value can be larger than the slice read by the next recv or peek call because it includes all queued octets, and not only the octets that may be returned as a contiguous slice.

Trait Implementations

impl<'d> ErrorType for TcpReader<'d>

type Error = Error

Error type of all the IO operations on this type.

impl<'d> Read for TcpReader<'d>

async fn read( &mut self, buf: &mut [u8], ) -> Result<usize, <TcpReader<'d> as ErrorType>::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

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

Read the exact number of bytes required to fill buf.

impl<'d> ReadReady for TcpReader<'d>

fn read_ready(&mut self) -> Result<bool, <TcpReader<'d> as ErrorType>::Error>

Get whether the reader is ready for immediately reading.