Struct Writer 

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

Writer compresses data using the S2 stream format

The stream format includes:

• Stream identifier magic bytes
• Framed compressed blocks with CRC checksums
• Support for flushing and proper stream termination

Example

use minlz::Writer;
use std::io::Write;

let mut compressed = Vec::new();
{
    let mut writer = Writer::new(&mut compressed);
    writer.write_all(b"Hello, World!").unwrap();
    writer.flush().unwrap();
} // Writer is dropped and finalized here

assert!(compressed.len() > 0);

Implementations

impl<W: Write> Writer<W>

pub fn new(writer: W) -> Self

Create a new Writer with default block size (1MB)

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

Create a new Writer with a specific block size

Block size must be between 4KB and 4MB

pub fn with_index(writer: W) -> Self

Create a new Writer with index support enabled

The index allows seeking in the compressed stream by recording compressed/uncompressed offset pairs at regular intervals.

Example

use minlz::Writer;
use std::io::Write;

let mut compressed = Vec::new();
{
    let mut writer = Writer::with_index(&mut compressed);
    writer.write_all(b"Hello, World!").unwrap();
} // Index is appended when Writer is dropped

pub fn with_index_and_block_size(writer: W, block_size: usize) -> Self

Create a new Writer with index support and custom block size

pub fn with_padding(writer: W, padding: usize) -> Self

Create a new Writer with padding enabled

The output will be padded to be a multiple of padding bytes. The padding uses skippable frames filled with random data. Padding must be > 1 and <= 4MB.

Example

use minlz::Writer;
use std::io::Write;

let mut compressed = Vec::new();
{
    let mut writer = Writer::with_padding(&mut compressed, 1024);
    writer.write_all(b"Hello, World!").unwrap();
} // Padding is applied when Writer is dropped

// Output size will be a multiple of 1024
assert_eq!(compressed.len() % 1024, 0);

pub fn enable_index(&mut self)

Enable index tracking on this writer

This can be called after construction to enable index support. The index will be appended when the writer is dropped.

pub fn reset(&mut self, writer: W) -> W

Reset the writer to use a new underlying writer

pub fn get_ref(&self) -> &W

Get a reference to the underlying writer

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

Get a mutable reference to the underlying writer

Trait Implementations

impl<W: Write> Drop for Writer<W>

fn drop(&mut self)

Executes the destructor for this type.

impl<W: Write> Write for Writer<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.