Struct s2n_quic::stream::ReceiveStream

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

A QUIC stream that is only allowed to receive data.

Implementations

impl ReceiveStream

pub fn id(&self) -> u64

Returns the stream’s identifier

This value is unique to a particular connection. The format follows the same as what is defined in the QUIC Transport RFC.

Examples

while let Some(stream) = connection.accept_receive_stream().await? {
    println!("New stream's id: {}", stream.id());
}

pub fn connection(&self) -> Handle

Returns the connection::Handle associated with the stream.

Examples

let connection = stream.connection();

println!("The stream's connection id is: {}", connection.id());

pub async fn receive(&mut self) -> Result<Option<Bytes>>

Receives a chunk of data from the stream.

Return value

The function returns:

• Ok(Some(chunk)) if the stream is open and data was available.
• Ok(None) if the stream was finished and all of the data was consumed.
• Err(e) if the stream encountered a stream::Error.

Examples

while let Some(chunk) = stream.receive().await? {
    println!("received: {:?}", chunk);
}

println!("finished");

pub fn poll_receive( &mut self, cx: &mut Context<'_> ) -> Poll<Result<Option<Bytes>>>

Poll for a chunk of data from the stream.

Return value

The function returns:

• Poll::Pending if the stream is waiting to receive data from the peer. In this case, the caller should retry receiving after the Waker on the provided Context is notified.
• Poll::Ready(Ok(Some(chunk))) if the stream is open and data was available.
• Poll::Ready(Ok(None)) if the stream was finished and all of the data was consumed.
• Poll::Ready(Err(e)) if the stream encountered a stream::Error.

pub async fn receive_vectored( &mut self, chunks: &mut [Bytes] ) -> Result<(usize, bool)>

Receives a slice of chunks of data from the stream.

This can be more efficient than calling receive for each chunk, especially when receiving large amounts of data.

Return value

The function returns:

• Ok((count, is_open)) if the stream received data into the slice, where count was the number of chunks received, and is_open indicating if the stream is still open. If is_open == true, count will be at least 1. If is_open == false, future calls to receive_vectored will always return Ok((0, false)).
• Err(e) if the stream encountered a stream::Error.

Examples

loop {
    let mut chunks = [Bytes::new(), Bytes::new(), Bytes::new()];
    let (count, is_open) = stream.receive_vectored(&mut chunks).await?;

    for chunk in &chunks[..count] {
        println!("received: {:?}", chunk);
    }

    if !is_open {
        break;
    }
}

println!("finished");

pub fn poll_receive_vectored( &mut self, chunks: &mut [Bytes], cx: &mut Context<'_> ) -> Poll<Result<(usize, bool)>>

Polls for receiving a slice of chunks of data from the stream.

Return value

The function returns:

• Poll::Pending if the stream is waiting to receive data from the peer. In this case, the caller should retry receiving after the Waker on the provided Context is notified.
• Poll::Ready(Ok((count, is_open))) if the stream received data into the slice, where count was the number of chunks received, and is_open indicating if the stream is still open. If is_open == true, count will be at least 1. If is_open == false, future calls to poll_receive_vectored will always return Poll::Ready(Ok((0, false))).
• Poll::Ready(Err(e)) if the stream encountered a stream::Error.

pub fn stop_sending(&mut self, error_code: Error) -> Result<()>

Notifies the peer to stop sending data on the stream.

This requests the peer to finish the stream as soon as possible by issuing a reset with the provided error_code.

Since this is merely a request for the peer to reset the stream, the stream will not immediately be in a reset state after issuing this call.

If the stream has already been reset by the peer or if all data has been received, the call will not trigger any action.

Return value

The function returns:

• Ok(()) if the stop sending message was enqueued for the peer.
• Err(e) if the stream encountered a stream::Error.

Examples

while let Some(stream) = connection.accept_receive_stream().await? {
    stream.stop_sending(123u8.into());
}

Trait Implementations

impl AsyncRead for ReceiveStream

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

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

impl AsyncRead for ReceiveStream

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

Attempts to read from the AsyncRead into buf.

impl Debug for ReceiveStream

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

Formats the value using the given formatter.

impl From<ReceiveStream> for PeerStream

fn from(stream: ReceiveStream) -> Self

Converts to this type from the input type.

impl From<ReceiveStream> for Stream

fn from(stream: ReceiveStream) -> Self

Converts to this type from the input type.

impl SplittableStream for ReceiveStream

fn split(self) -> (Option<ReceiveStream>, Option<SendStream>)

Splits the stream into ReceiveStream and SendStream halves

impl Stream for ReceiveStream

type Item = Result<Bytes, StreamError>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.