Struct AsyncZstdReader 

pub struct AsyncZstdReader<'dict, R> { /* private fields */ }

An reader that decompresses a zstd stream from an underlying async reader. Works as either a tokio or futures reader if their respective features are enabled.

The underyling reader R should implement the following traits:

• tokio
  • tokio::io::AsyncBufRead (required for tokio::io::AsyncRead and tokio::io::AsyncBufRead impls)
  • (Optional) tokio::io::AsyncSeek (used when calling .seekable())
• futures
  • futures::AsyncBufRead (required for futures::AsyncRead and futures::AsyncBufRead impls)
  • (Optional) futures::AsyncSeek (used when calling .seekable())

For sync I/O support, see crate::ZstdReader.

Construction

Create a builder using AsyncZstdReader::builder_tokio (recommended for tokio) or AsyncZstdReader::builder_futures (recommended for futures); or use [ZstdReader::builder_buffered] to use a custom buffer for either. See ZstdReaderBuilder for build options. Call [AsyncZstdReaderBuilder::build] to build the AsyncZstdReader instance.

// Tokio example
let reader = zstd_framed::AsyncZstdReader::builder_tokio(compressed_file)
    // .with_seek_table(table) // Provide a seek table if available
    .build()?;

// futures example
let reader = zstd_framed::AsyncZstdReader::builder_futures(compressed_file)
    // .with_seek_table(table) // Provide a seek table if available
    .build()?;

Buffering

The decompressed zstd output is always buffered internally. Since the reader must also implement tokio::io::AsyncBufRead / futures::AsyncBufRead, the compressed input must also be buffered.

AsyncZstdReader::builder_tokio and AsyncZstdReader::builder_futures will wrap any reader implmenting tokio::io::AsyncRead or futures::AsyncRead (respectively) with a recommended buffer size for the input stream. For more control over how the input gets buffered, you can instead use AsyncZstdReader::builder_buffered.

Seeking

If the underlying reader is seekable (i.e. it implements either tokio::io::AsyncSeek or futures::AsyncSeek), you can call .seekable() to convert it to a seekable reader. See AsyncZstdSeekableReader for notes and caveats about seeking.

Implementations

impl<'dict, R> AsyncZstdReader<'dict, R>

pub fn builder_tokio(reader: R) -> ZstdReaderBuilder<BufReader<R>>

where R: AsyncRead,

Create a new zstd reader that decompresses the zstd stream from the underlying Tokio reader. The provided reader will be wrapped with an appropriately-sized buffer.

pub fn builder_futures(reader: R) -> ZstdReaderBuilder<BufReader<R>>

where R: AsyncRead,

Create a new zstd reader that decompresses the zstd stream from the underlying futures reader. The provided reader will be wrapped with an appropriately-sized buffer.

pub fn builder_buffered(reader: R) -> ZstdReaderBuilder<R>

Create a new zstd reader that decompresses the zstd stream from the underlying reader. The underlying reader must implement either tokio::io::AsyncBufRead or futures::AsyncBufRead, and its buffer will be used directly. When in doubt, use one of the other builder methods to use an appropriate buffer size for decompressing a zstd stream.

pub fn seekable(self) -> AsyncZstdSeekableReader<'dict, R>

Wrap the reader with AsyncZstdSeekableReader, which adds support for seeking if the underlying reader supports seeking.

Trait Implementations

impl<R> AsyncBufRead for AsyncZstdReader<'_, R>

where R: AsyncBufRead,

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<R> AsyncBufRead for AsyncZstdReader<'_, R>

where R: AsyncBufRead,

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

Attempt 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<R> AsyncRead for AsyncZstdReader<'_, R>

where R: AsyncBufRead,

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

Attempts to read from the AsyncRead into buf.

impl<R> AsyncRead for AsyncZstdReader<'_, R>

where R: AsyncBufRead,

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

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

impl<'__pin, 'dict, R> Unpin for AsyncZstdReader<'dict, R>

where PinnedFieldsOf<__Origin<'__pin, 'dict, R>>: Unpin,