Struct Compressor 

pub struct Compressor<W: Write + Seek> { /* private fields */ }

Stateful compressor that maintains compression state across multiple writes

Compressor implements Write and compresses data incrementally as it’s written. This is useful for compressing large data streams or data that’s generated dynamically without knowing the total size in advance.

Examples

use mismall::stream::Compressor;
use std::fs::File;
use std::io::Write;

let output_file = File::create("compressed.small")?;
let mut compressor = Compressor::new(output_file, "data.txt", None);

compressor.write_all(b"Hello, ")?;
compressor.write_all(b"world!")?;
compressor.finish()?; // Important: call finish() to complete compression

println!("Data compressed successfully!");

Implementations

impl<W: Write + Seek> Compressor<W>

pub fn new(destination: W, filename: &str, password: Option<&str>) -> Self

Create a new compressor

Arguments

• destination - Destination stream for compressed data
• filename - Original filename (stored in metadata)
• password - Optional password for encryption

Example

use mismall::stream::Compressor;
use std::fs::File;

let file = File::create("output.small")?;
let compressor = Compressor::new(file, "data.txt", None);

pub fn with_chunk_size(self, chunk_size: usize) -> Self

Set custom chunk size for compression

Larger chunk sizes use more memory but may improve performance. Smaller chunk sizes use less memory but may be slower.

Arguments

• chunk_size - Chunk size in bytes (64KB to 1GB)

Example

use mismall::stream::Compressor;
use std::fs::File;

let output = File::create("data.txt.small")?;
let compressor = Compressor::new(output, "data.txt", None)
    .with_chunk_size(64 * 1024 * 1024); // 64MB

pub fn with_progress_callback<F>(self, callback: F) -> Self

where F: FnMut(&ProgressInfo) + Send + Sync + 'static,

Set progress callback for real-time updates

The callback will be called periodically with progress information during the compression process.

Arguments

• callback - Function that receives ProgressInfo

Example

use mismall::stream::Compressor;
use std::fs::File;

let output = File::create("data.txt.small")?;
let compressor = Compressor::new(output, "data.txt", None)
    .with_progress_callback(|progress: &mismall::progress::ProgressInfo| {
        println!("Progress: {}%", progress.percentage);
    });

pub fn bytes_written(&self) -> u64

Get the total bytes written so far

Returns

Number of bytes written to the destination

Example

use mismall::stream::Compressor;
use std::fs::File;
use std::io::Write;

let output = File::create("data.txt.small")?;
let mut compressor = Compressor::new(output, "data.txt", None);
compressor.write_all(b"Hello")?;
println!("Written {} bytes", compressor.bytes_written());

pub fn is_finished(&self) -> bool

Check if compression is finished

Returns

true if finish() has been called successfully

Example

use mismall::stream::Compressor;
use std::fs::File;

let output = File::create("data.txt.small")?;
let compressor = Compressor::new(output, "data.txt", None);
assert!(!compressor.is_finished());

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

Complete the compression process

This method must be called after all data has been written to finalize the compression and write proper headers/footers. After calling finish(), no more data can be written.

Returns

Result<()> on success or Err(MismallError) on failure

Example

use mismall::stream::Compressor;
use std::fs::File;
use std::io::Write;

let output = File::create("data.txt.small")?;
let mut compressor = Compressor::new(output, "data.txt", None);
compressor.write_all(b"Hello, world!")?;
compressor.finish()?; // Finalize compression

Trait Implementations

impl<W: Write + Seek> Write for Compressor<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.