Struct quinn::generic::RecvStream

pub struct RecvStream<S> where
    S: Session,  { /* fields omitted */ }

A stream that can only be used to receive data

stop(0) is implicitly called on drop unless:

• A variant of ReadError has been emitted by read(), read_exact() or read_unordered()
• stop() was called explicitly

Implementations

impl<S> RecvStream<S> where
    S: Session, 

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

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, S>

Read an exact number of bytes contiguously from the stream.

See read() for details.

pub fn read_chunk(
    &mut self,
    max_length: usize,
    ordered: bool
) -> ReadChunk<'_, S>

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 have reduced overhead and higher throughput, and should therefore be preferred when applicable.

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

pub fn read_chunks<'a>(&'a mut self, bufs: &'a mut [Bytes]) -> ReadChunks<'a, S>

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.

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

Convenience method to read all remaining data into a buffer

The returned future fails with ReadToEndError::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>

Stop accepting data

Discards unread data and notifies the peer to stop transmitting. Once stopped, further attempts to operate on a stream will yield UnknownStream 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

Trait Implementations

impl<S> AsyncRead for RecvStream<S> where
    S: Session, 

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<S> AsyncRead for RecvStream<S> where
    S: Session, 

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

Attempts to read from the AsyncRead into buf.

impl<S: Debug> Debug for RecvStream<S> where
    S: Session, 

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

Formats the value using the given formatter.

impl<S> Drop for RecvStream<S> where
    S: Session, 

fn drop(&mut self)

Executes the destructor for this type.