Struct Decoder 

pub struct Decoder<'a, R> {
    reader: Reader<R, Decoder<'a>>,
}

A decoder that decompress input data from another Read.

This allows to read a stream of compressed data (good for files or heavy network stream).

Fields

reader: Reader<R, Decoder<'a>>

Implementations

impl<R: Read> Decoder<'static, BufReader<R>>

pub fn new(reader: R) -> Result<Self>

Creates a new decoder.

This wraps reader in a BufReader sized the way zstd likes, so there is no need to do that yourself. If what you have already implements BufRead - a &[u8], say - use Decoder::with_buffer() instead and save the second layer of buffering.

Use Self::try_new() to recover the reader if initialization fails.

pub fn try_new(reader: R) -> Result<Self, (R, Error)>

Creates a new decoder, returning the original reader on error.

Like Self::new(), this wraps the reader in a BufReader on success. On error, it returns the original R, without buffering. Construction does not read from or consume the reader.

impl<R: BufRead> Decoder<'static, R>

pub fn with_buffer(reader: R) -> Result<Self>

Creates a new decoder around a BufRead.

Unlike Decoder::new(), this adds no buffering of its own, so give it something with a reasonable buffer already - new uses zstd’s preferred input size for exactly that reason.

Use Self::try_with_buffer() to recover the reader if initialization fails.

pub fn try_with_buffer(reader: R) -> Result<Self, (R, Error)>

Creates a decoder around a BufRead, returning the reader on error.

Like Self::with_buffer(), this adds no buffering of its own. Construction does not read from or consume the reader.

pub fn with_dictionary(reader: R, dictionary: &[u8]) -> Result<Self>

Creates a new decoder, using an existing dictionary.

The dictionary must be the same as the one used during compression.

Use Self::try_with_dictionary() to recover the reader if initialization fails.

pub fn try_with_dictionary( reader: R, dictionary: &[u8], ) -> Result<Self, (R, Error)>

Creates a decoder using a dictionary, returning the reader on error.

The dictionary must be the same as the one used during compression. Construction does not read from or consume the reader.

impl<'a, R: BufRead> Decoder<'a, R>

pub fn with_context(reader: R, context: &'a mut DCtx<'static>) -> Self

Creates a new decoder which employs the provided context for deserialization.

pub fn single_frame(self) -> Self

Sets this Decoder to stop after the first frame.

By default, it keeps concatenating frames until EOF is reached.

pub fn with_prepared_dictionary<'b>( reader: R, dictionary: &'a DecoderDictionary<'b>, ) -> Result<Self>

where 'b: 'a,

Creates a new decoder, using an existing DecoderDictionary.

The dictionary must be the same as the one used during compression.

Use Self::try_with_prepared_dictionary() to recover the reader if initialization fails.

pub fn try_with_prepared_dictionary<'b>( reader: R, dictionary: &'a DecoderDictionary<'b>, ) -> Result<Self, (R, Error)>

where 'b: 'a,

Creates a decoder using a prepared dictionary, returning the reader on error.

The dictionary must be the same as the one used during compression. Construction does not read from or consume the reader.

pub fn with_ref_prefix<'b>(reader: R, ref_prefix: &'b [u8]) -> Result<Self>

where 'b: 'a,

Creates a new decoder, using a ref prefix.

The prefix must be the same as the one used during compression.

Use Self::try_with_ref_prefix() to recover the reader if initialization fails.

pub fn try_with_ref_prefix<'b>( reader: R, ref_prefix: &'b [u8], ) -> Result<Self, (R, Error)>

where 'b: 'a,

Creates a decoder using a reference prefix, returning the reader on error.

The prefix must be the same as the one used during compression. Construction does not read from or consume the reader.

pub fn recommended_output_size() -> usize

Recommendation for the size of the output buffer.

pub fn get_ref(&self) -> &R

Acquire a reference to the underlying reader.

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

Acquire a mutable reference to the underlying reader.

Note that mutation of the reader may result in surprising results if this decoder is continued to be used.

pub fn into_inner(self) -> R

Return the inner reader without consuming additional input.

This does not read from the underlying reader or try to finish the current frame. Any buffered decoded data is discarded, and the reader is returned at its current position.

Use Self::finish() to try to consume any remaining frame input before returning the reader.

pub fn finish_frame(&mut self) -> Result<()>

Try to consume the remaining input from the current frame.

zstd can hand out the last of the decoded data before it has read the frame epilogue, so a reader that stops as soon as it has the bytes it wanted leaves the input somewhere inside the frame. Call this to line the reader back up with the end of the frame - for instance to carry on reading whatever follows the compressed section.

This does not discard unread decoded data. If there is still output to read, it may stop before reaching the end of the frame.

This does not touch the underlying reader if the frame is already complete or if nothing has been read from this decoder yet, and never starts decoding the next frame.

pub fn finish(self) -> R

Return the inner Read.

Calling finish() is not required after reading a stream - just use it if you need to get the Read back.

This tries to consume any remaining input from the current frame first - see Self::finish_frame(). That may read from the underlying reader, and any error doing so is ignored; call finish_frame() directly if you need to see it.

To return the reader without consuming additional input, use Self::into_inner().

pub fn set_parameter(&mut self, parameter: DParameter) -> Result<()>

Sets a decompression parameter on the decompression stream.

pub fn window_log_max(&mut self, log_distance: u32) -> Result<()>

Sets the maximum back-reference distance.

The actual maximum distance is going to be 2^log_distance.

This will need to at least match the value set when compressing.

Trait Implementations

impl<R: BufRead> Read for Decoder<'_, R>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Reads all bytes until EOF in this source, placing them into buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_, u8>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact( &mut self, cursor: BorrowedCursor<'_, u8>, ) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source.

fn read_le<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in little-endian order.

fn read_be<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in big-endian order.