Struct quinn::RecvStream

pub struct RecvStream { /* fields omitted */ }

A stream that can only be used to receive data

stop(0) is implicitly called on drop unless:

• ReadError::Finished has been emitted, or
• stop was called explicitly

Implementations

impl RecvStream

pub fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a>

Read data contiguously from the stream.

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

Applications involving bulk data transfer should consider using unordered reads for improved performance.

Panics

• If used after read_unordered on the same stream. This is forbidden because an unordered read could consume a segment of data from a location other than the start of the receive buffer, making it impossible for future

pub fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a>

Read an exact number of bytes contiguously from the stream.

See read for details.

pub fn read_unordered(&mut self) -> ReadUnordered<'_>

Read a segment of data from any offset in the stream.

Yields a segment of data and their offset in the stream, or None if the stream was finished. Segments may be received in any order and may overlap.

Unordered reads have reduced overhead and higher throughput, and should therefore be preferred when applicable.

pub fn read_to_end(self, size_limit: usize) -> ReadToEnd

Convenience method to read all remaining data into a buffer

The returned future fails with ReadToEnd::TooLong if it’s longer than size_limit bytes. 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.

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

Close the receive stream immediately.

The peer is notified and will cease transmitting on this stream, as if it had reset the stream itself. Further data may still be received on this stream if it was already in flight. Once called, a ReadError::Reset should be expected soon, although a peer might manage to finish the stream before it receives the reset, and a misbehaving peer might ignore the request entirely and continue sending until halted by flow control.

Has no effect if the incoming stream already finished, even if the local application hasn’t yet read all buffered data.

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.

pub 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 AsyncRead for RecvStream

unsafe fn prepare_uninitialized_buffer(&self, _: &mut [MaybeUninit<u8>]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

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

Attempts to read from the AsyncRead into buf.

pub fn poll_read_buf<B>(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &mut B
) -> Poll<Result<usize, Error>> where
    B: BufMut, 

Pulls some bytes from this source into the specified BufMut, returning how many bytes were read.

impl Debug for RecvStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for RecvStream

fn drop(&mut self)

Executes the destructor for this type.