Struct ZstdStreamEncoder 

pub struct ZstdStreamEncoder<W: Write> { /* private fields */ }

Streaming Zstandard encoder that implements Write.

Data written to this encoder is buffered internally. When the internal buffer reaches block_size bytes it is automatically flushed as a complete Zstandard frame to the inner writer (truly incremental). Any remaining data is flushed when finish is called.

The output is a sequence of valid concatenated Zstandard frames and can be decoded with decompress_multi_frame.

Important: you must call finish to flush the final (possibly partial) block. Dropping the encoder without calling finish will silently discard any buffered data.

Implementations

impl<W: Write> ZstdStreamEncoder<W>

pub fn new(writer: W, level: i32) -> Self

Create a new streaming encoder wrapping writer.

The level parameter controls the compression level passed to the underlying ZstdEncoder. The encoder uses a default block size of 128 KiB; use with_block_size to customise this.

pub fn with_dictionary(writer: W, level: i32, dict: Vec<u8>) -> Self

Create a new streaming encoder with a pre-trained dictionary.

Dictionary-based compression improves ratios for small payloads that share common patterns.

pub fn with_block_size(self, block_size: usize) -> Self

Set the block size used for incremental flushing.

When the internal buffer reaches this many bytes it is automatically compressed and written to the inner writer as a Zstandard frame.

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

Finish compression and return the inner writer.

This must be called to flush the final compressed data. Failing to call finish means all buffered data is lost.

Errors

Returns an io::Error if compression or writing to the inner writer fails.

pub fn buffered_bytes(&self) -> usize

Returns the number of uncompressed bytes currently buffered.

pub fn is_finished(&self) -> bool

Returns true if finish has already been called.

Trait Implementations

impl<W: Write> Write for ZstdStreamEncoder<W>

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

Buffer buf and flush a frame to the inner writer whenever the internal buffer reaches block_size.

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

Flush any buffered data as a Zstandard frame to the inner writer.

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.