Struct Decoder 

pub struct Decoder<'a, W: Write> {
    writer: Writer<W, Decoder<'a>>,
}

A decoder that decompress and forward data to another writer.

Don’t forget to call finish() after writing your stream content: it flushes the decompressed data, and is the only way to know whether the input stopped in the middle of a frame.

You can also use auto_flush() to automatically flush the writer on drop; note that this does not check for an incomplete frame.

Fields

writer: Writer<W, Decoder<'a>>

Implementations

impl<W: Write> Decoder<'static, W>

pub fn new(writer: W) -> Result<Self>

Creates a new decoder.

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

Creates a new decoder, using an existing dictionary.

(Provides better compression ratio for small files, but requires the dictionary to be present during decompression.)

impl<'a, W: Write> Decoder<'a, W>

pub fn with_writer(writer: Writer<W, Decoder<'a>>) -> Self

Creates a new decoder around the given prepared zio writer.

Examples

fn wrap<W: std::io::Write>(writer: W) -> zstd::stream::write::Decoder<'static, W> {
  let decoder = zstd::stream::raw::Decoder::new().unwrap();
  let writer = zstd::stream::zio::Writer::new(writer, decoder);
  zstd::stream::write::Decoder::with_writer(writer)
}

pub fn with_decoder(writer: W, decoder: Decoder<'a>) -> Self

Creates a new decoder around the given Write and raw decoder.

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

Creates a decoder that uses the provided context to decompress a stream.

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

where 'b: 'a,

Creates a new decoder, using an existing prepared DecoderDictionary.

(Provides better compression ratio for small files, but requires the dictionary to be present during decompression.)

pub fn get_ref(&self) -> &W

Acquires a reference to the underlying writer.

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

Acquires a mutable reference to the underlying writer.

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

pub fn into_inner(self) -> W

Returns the inner Write.

Careful: this neither flushes the decompressed data nor checks that the input ended on a complete frame. Use finish(self) for that.

pub fn finish(self) -> Result<W>

Finishes the stream.

This flushes all the decompressed data, and returns an UnexpectedEof error if the data written so far does not end on a complete frame.

This returns the inner writer in case you need it.

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

Attempts to finish the stream.

Same as finish(self), but does not consume self.

write on this object will fail after do_finish has succeeded.

pub fn recommended_input_size() -> usize

Return a recommendation for the size of data to write at once.

pub fn auto_flush(self) -> AutoFlushDecoder<'a, W>

Returns a wrapper around self that will flush the stream on drop.

pub fn on_flush<F: FnMut(Result<()>)>(self, f: F) -> AutoFlushDecoder<'a, W, F>

Returns a decoder that will flush the stream on drop.

Calls the given callback with the result from flush(). This runs during drop so it’s important that the provided callback doesn’t panic. It is not called if the wrapped writer panicked.

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<W: Write> Write for Decoder<'_, W>

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

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

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

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

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

where Self: Sized,

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