Struct ZipFileBuilder 

pub struct ZipFileBuilder { /* private fields */ }

Compresses the contents of a single file entry independently of any ZipWriter, so that the CPU-intensive part of adding files to an archive can be parallelized.

The builder compresses the data written to it into memory as it arrives, while tracking the metadata (CRC-32 and sizes) that the archive will need. Once ZipFileBuilder::finish has been called, the resulting PreparedZipFile can be appended to an archive with ZipWriter::add_prepared_file, which copies the already-compressed bytes without recompressing them.

Builders are self-contained: they can be created, written to and finished on other threads while a ZipWriter is in use, and the prepared files appended to the archive as they become ready.

Encryption is not supported; pass options without encryption or creation will fail.

use std::io::{Cursor, Write};
use zip::ZipWriter;
use zip::write::{SimpleFileOptions, ZipFileBuilder};

let options = SimpleFileOptions::default();

// Compress each file on its own thread...
let handles = ["first.txt", "second.txt"].map(|name| {
    std::thread::spawn(move || -> zip::result::ZipResult<_> {
        let mut builder = ZipFileBuilder::new(name, options)?;
        builder.write_all(b"Contents compressed off-thread")?;
        builder.finish()
    })
});

// ...then append them to the archive serially.
let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
for handle in handles {
    zip.add_prepared_file(handle.join().unwrap()?)?;
}
let zip_bytes = zip.finish()?.into_inner();

Implementations

impl ZipFileBuilder

pub fn new<N: AsRef<str>, T: FileOptionExtension>( name: N, options: FileOptions<'_, '_, T>, ) -> ZipResult<Self>

Creates a builder that compresses a file’s contents using the compression settings from options.

Fails if options requests encryption or an unsupported compression method or level.

pub fn new_from_path<T: FileOptionExtension, P: AsRef<Path>>( path: P, options: FileOptions<'_, '_, T>, ) -> ZipResult<Self>

Like ZipFileBuilder::new, but takes a Path as the file name.

This function ensures that the ‘/’ path separator is used and normalizes . and ... It ignores any .. or Windows drive letter that would produce a path outside the ZIP file’s root.

pub fn finish(self) -> ZipResult<PreparedZipFile>

Finishes compressing the file, and returns a PreparedZipFile that can be appended to an archive with ZipWriter::add_prepared_file.

Trait Implementations

impl Debug for ZipFileBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Write for ZipFileBuilder

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.