Struct RecvStream 

pub struct RecvStream { /* private fields */ }

A byte stream received from the remote peer.

Either side may close with an error code, or the peer may close with a FIN.

Implementations

impl RecvStream

pub async fn read(&mut self, max: usize) -> Result<Option<Bytes>, Error>

Read the next chunk of data with the provided maximum size.

This returns a chunk of data instead of copying, which can be more efficient.

pub async fn read_buf<B: BufMut>( &mut self, buf: &mut B, ) -> Result<Option<usize>, Error>

Read some data into the provided buffer.

Returns the (non-zero) number of bytes read, or None if the stream is closed. Advances the buffer by the number of bytes read.

pub fn stop(&mut self, reason: &str)

Abort reading from the stream with the given reason.

pub async fn closed(&self) -> Result<Option<u8>, Error>

Block until the stream has closed and return the error code, if any.

Trait Implementations

impl AsyncRead for RecvStream

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

Attempt to read from the AsyncRead into buf.

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

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl Drop for RecvStream

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.

impl RecvStream for RecvStream

Available on target_family=wasm only.

type Error = Error

Error type returned by receive-side stream operations.

async fn read(&mut self, dst: &mut [u8]) -> Result<Option<usize>, Self::Error>

Read the next chunk of data, up to the max size.

fn stop(&mut self, code: u32)

Send a STOP_SENDING QUIC code, informing the peer that no more data will be read.

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

Block until the stream has been closed by either side.

fn read_buf<B>( &mut self, buf: &mut B, ) -> impl Future<Output = Result<Option<usize>, Self::Error>> + MaybeSend

where B: BufMut + MaybeSend,

Read some data into the provided buffer.

fn read_chunk( &mut self, max: usize, ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + MaybeSend

Read the next chunk of data, up to the max size.

fn read_all( &mut self, ) -> impl Future<Output = Result<Bytes, Self::Error>> + MaybeSend

Helper to keep reading until the stream is closed.

fn read_all_buf<B>( &mut self, buf: &mut B, ) -> impl Future<Output = Result<usize, Self::Error>> + MaybeSend

where B: BufMut + MaybeSend,

Helper to keep reading until the buffer is full.