Struct RecvStream

pub struct RecvStream(/* private fields */);

Methods from Deref<Target = RecvStream>

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

Read data contiguously from the stream.

Yields the number of bytes read into buf on success, or None if the stream was finished.

This operation is cancel-safe.

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

Read an exact number of bytes contiguously from the stream.

See read() for details. This operation is not cancel-safe.

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

Attempts to read from the stream into the provided buffer

On success, returns Poll::Ready(Ok(num_bytes_read)) and places data into buf. If this returns zero bytes read (and buf has a non-zero length), that indicates that the remote side has finished the stream and the local side has already read all bytes.

If no data is available for reading, this returns Poll::Pending and arranges for the current task (via cx.waker()) to be notified when the stream becomes readable or is closed.

pub fn poll_read_buf( &mut self, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), ReadError>>

Attempts to read from the stream into the provided buffer, which may be uninitialized

On success, returns Poll::Ready(Ok(())) and places data into the unfilled portion of buf. If this does not write any bytes to buf (and buf.remaining() is non-zero), that indicates that the remote side has finished the stream and the local side has already read all bytes.

If no data is available for reading, this returns Poll::Pending and arranges for the current task (via cx.waker()) to be notified when the stream becomes readable or is closed.

pub async fn read_chunk( &mut self, max_length: usize, ordered: bool, ) -> Result<Option<Chunk>, ReadError>

Read the next segment of data

Yields None if the stream was finished. Otherwise, yields a segment of data and its offset in the stream. If ordered is true, the chunk’s offset will be immediately after the last data yielded by read() or read_chunk(). If ordered is false, segments may be received in any order, and the Chunk’s offset field can be used to determine ordering in the caller. Unordered reads are less prone to head-of-line blocking within a stream, but require the application to manage reassembling the original data.

Slightly more efficient than read due to not copying. Chunk boundaries do not correspond to peer writes, and hence cannot be used as framing.

This operation is cancel-safe.

pub async fn read_chunks( &mut self, bufs: &mut [Bytes], ) -> Result<Option<usize>, ReadError>

Read the next segments of data

Fills bufs with the segments of data beginning immediately after the last data yielded by read or read_chunk, or None if the stream was finished.

Slightly more efficient than read due to not copying. Chunk boundaries do not correspond to peer writes, and hence cannot be used as framing.

This operation is cancel-safe.

pub async fn read_to_end( &mut self, size_limit: usize, ) -> Result<Vec<u8>, ReadToEndError>

Convenience method to read all remaining data into a buffer

Fails with ReadToEndError::TooLong on reading more than size_limit bytes, discarding all data read. Uses unordered reads to be more efficient than using AsyncRead would allow. size_limit should be set to limit worst-case memory use.

If unordered reads have already been made, the resulting buffer may have gaps containing arbitrary data.

This operation is not cancel-safe.

pub fn stop(&mut self, error_code: VarInt) -> Result<(), ClosedStream>

Stop accepting data

Discards unread data and notifies the peer to stop transmitting. Once stopped, further attempts to operate on a stream will yield ClosedStream errors.

pub fn is_0rtt(&self) -> bool

Check if this stream has been opened during 0-RTT.

In which case any non-idempotent request should be considered dangerous at the application level. Because read data is subject to replay attacks.

pub fn id(&self) -> StreamId

Get the identity of this stream

pub async fn received_reset(&mut self) -> Result<Option<VarInt>, ResetError>

Completes when the stream has been reset by the peer or otherwise closed

Yields Some with the reset error code when the stream is reset by the peer. Yields None when the stream was previously stop()ed, or when the stream was finish()ed by the peer and all data has been received, after which it is no longer meaningful for the stream to be reset.

This operation is cancel-safe.

Trait Implementations

impl AsyncRead for RecvStream

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

Attempts to read from the AsyncRead into buf.

impl Deref for RecvStream

type Target = RecvStream

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for RecvStream

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.