Struct StreamReader

pub struct StreamReader<S, B> { /* private fields */ }

Convert a Stream of byte chunks into an AsyncRead.

This type performs the inverse operation of ReaderStream.

This type also implements the AsyncBufRead trait, so you can use it to read a Stream of byte chunks line-by-line. See the examples below.

Example

use bytes::Bytes;
use tokio::io::{AsyncReadExt, Result};
use tokio_util::io::StreamReader;

// Create a stream from an iterator.
let stream = tokio_stream::iter(vec![
    Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
    Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
    Result::Ok(Bytes::from_static(&[8, 9, 10, 11])),
]);

// Convert it to an AsyncRead.
let mut read = StreamReader::new(stream);

// Read five bytes from the stream.
let mut buf = [0; 5];
read.read_exact(&mut buf).await?;
assert_eq!(buf, [0, 1, 2, 3, 4]);

// Read the rest of the current chunk.
assert_eq!(read.read(&mut buf).await?, 3);
assert_eq!(&buf[..3], [5, 6, 7]);

// Read the next chunk.
assert_eq!(read.read(&mut buf).await?, 4);
assert_eq!(&buf[..4], [8, 9, 10, 11]);

// We have now reached the end.
assert_eq!(read.read(&mut buf).await?, 0);

If the stream produces errors which are not std::io::Error, the errors can be converted using StreamExt to map each element.

use bytes::Bytes;
use tokio::io::AsyncReadExt;
use tokio_util::io::StreamReader;
use tokio_stream::StreamExt;

// Create a stream from an iterator, including an error.
let stream = tokio_stream::iter(vec![
    Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
    Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
    Result::Err("Something bad happened!")
]);

// Use StreamExt to map the stream and error to a std::io::Error
let stream = stream.map(|result| result.map_err(|err| {
    std::io::Error::new(std::io::ErrorKind::Other, err)
}));

// Convert it to an AsyncRead.
let mut read = StreamReader::new(stream);

// Read five bytes from the stream.
let mut buf = [0; 5];
read.read_exact(&mut buf).await?;
assert_eq!(buf, [0, 1, 2, 3, 4]);

// Read the rest of the current chunk.
assert_eq!(read.read(&mut buf).await?, 3);
assert_eq!(&buf[..3], [5, 6, 7]);

// Reading the next chunk will produce an error
let error = read.read(&mut buf).await.unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::Other);
assert_eq!(error.into_inner().unwrap().to_string(), "Something bad happened!");

// We have now reached the end.
assert_eq!(read.read(&mut buf).await?, 0);

Using the AsyncBufRead impl, you can read a Stream of byte chunks line-by-line. Note that you will usually also need to convert the error type when doing this. See the second example for an explanation of how to do this.

use tokio::io::{Result, AsyncBufReadExt};
use tokio_util::io::StreamReader;

// Create a stream of byte chunks.
let stream = tokio_stream::iter(vec![
    Result::Ok(b"The first line.\n".as_slice()),
    Result::Ok(b"The second line.".as_slice()),
    Result::Ok(b"\nThe third".as_slice()),
    Result::Ok(b" line.\nThe fourth line.\nThe fifth line.\n".as_slice()),
]);

// Convert it to an AsyncRead.
let mut read = StreamReader::new(stream);

// Loop through the lines from the `StreamReader`.
let mut line = String::new();
let mut lines = Vec::new();
loop {
    line.clear();
    let len = read.read_line(&mut line).await?;
    if len == 0 { break; }
    lines.push(line.clone());
}

// Verify that we got the lines we expected.
assert_eq!(
    lines,
    vec![
        "The first line.\n",
        "The second line.\n",
        "The third line.\n",
        "The fourth line.\n",
        "The fifth line.\n",
    ]
);

Implementations

impl<S, B, E> StreamReader<S, B>

where S: Stream<Item = Result<B, E>>, B: Buf, E: Into<Error>,

pub fn new(stream: S) -> Self

Convert a stream of byte chunks into an AsyncRead.

The item should be a Result with the ok variant being something that implements the Buf trait (e.g. Vec<u8> or Bytes). The error should be convertible into an io error.

pub fn into_inner_with_chunk(self) -> (S, Option<B>)

Consumes this StreamReader, returning a Tuple consisting of the underlying stream and an Option of the internal buffer, which is Some in case the buffer contains elements.

impl<S, B> StreamReader<S, B>

pub fn get_ref(&self) -> &S

Gets a reference to the underlying stream.

It is inadvisable to directly read from the underlying stream.

pub fn get_mut(&mut self) -> &mut S

Gets a mutable reference to the underlying stream.

It is inadvisable to directly read from the underlying stream.

pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut S>

Gets a pinned mutable reference to the underlying stream.

It is inadvisable to directly read from the underlying stream.

pub fn into_inner(self) -> S

Consumes this BufWriter, returning the underlying stream.

Note that any leftover data in the internal buffer is lost. If you additionally want access to the internal buffer use into_inner_with_chunk.

Trait Implementations

impl<S, B, E> AsyncBufRead for StreamReader<S, B>

where S: Stream<Item = Result<B, E>>, B: Buf, E: Into<Error>,

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

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<S, B, E> AsyncRead for StreamReader<S, B>

where S: Stream<Item = Result<B, E>>, B: Buf, E: Into<Error>,

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, B: Debug> Debug for StreamReader<S, B>

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

Formats the value using the given formatter.

impl<S: Sink<T, Error = E>, B, E, T> Sink<T> for StreamReader<S, B>

type Error = E

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<S: Unpin, B> Unpin for StreamReader<S, B>