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.

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

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

Creates a new decoder around a BufRead.

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.

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.

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.

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 finish_frame(&mut self) -> Result<()>

Consume the rest of the current frame, so the underlying reader is left pointing just after it.

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 touch the underlying reader if the frame is already complete, 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 consumes the rest of the current frame first, so the reader is returned pointing just after it - 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.

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_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_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

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

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<'_>) -> 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<'_>) -> 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.