Struct zip::write::ZipWriter

pub struct ZipWriter<W: Write + Seek> { /* fields omitted */ }

ZIP archive generator

Handles the bookkeeping involved in building an archive, and provides an API to edit its contents.

use std::io::Write;
use zip::write::FileOptions;

// We use a buffer here, though you'd normally use a `File`
let mut buf = [0; 65536];
let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut buf[..]));

let options = zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored);
zip.start_file("hello_world.txt", options)?;
zip.write(b"Hello, World!")?;

// Apply the changes you've made.
// Dropping the `ZipWriter` will have the same effect, but may silently fail
zip.finish()?;

Implementations

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

pub fn new(inner: W) -> ZipWriter<W>

Initializes the archive.

Before writing to this object, the ZipWriter::start_file function should be called.

pub fn set_comment<S>(&mut self, comment: S) where
    S: Into<String>, 

Set ZIP archive comment.

pub fn start_file<S>(&mut self, name: S, options: FileOptions) -> ZipResult<()> where
    S: Into<String>, 

Create a file in the archive and start writing its’ contents.

The data should be written using the io::Write implementation on this ZipWriter

pub fn start_file_from_path(
    &mut self,
    path: &Path,
    options: FileOptions
) -> ZipResult<()>

👎 Deprecated since 0.5.7:

by stripping ..s from the path, the meaning of paths can change. Use start_file instead.

Starts a file, taking a Path as argument.

This function ensures that the ‘/’ path seperator is used. It also ignores all non ‘Normal’ Components, such as a starting ‘/’ or ‘..’ and ‘.’.

pub fn raw_copy_file_rename<S>(
    &mut self,
    file: ZipFile<'_>,
    name: S
) -> ZipResult<()> where
    S: Into<String>, 

Add a new file using the already compressed data from a ZIP file being read and renames it, this allows faster copies of the ZipFile since there is no need to decompress and compress it again. Any ZipFile metadata is copied and not checked, for example the file CRC.

use std::fs::File;
use std::io::{Read, Seek, Write};
use zip::{ZipArchive, ZipWriter};

fn copy_rename<R, W>(
    src: &mut ZipArchive<R>,
    dst: &mut ZipWriter<W>,
) -> zip::result::ZipResult<()>
where
    R: Read + Seek,
    W: Write + Seek,
{
    // Retrieve file entry by name
    let file = src.by_name("src_file.txt")?;

    // Copy and rename the previously obtained file entry to the destination zip archive
    dst.raw_copy_file_rename(file, "new_name.txt")?;

    Ok(())
}

pub fn raw_copy_file(&mut self, file: ZipFile<'_>) -> ZipResult<()>

Add a new file using the already compressed data from a ZIP file being read, this allows faster copies of the ZipFile since there is no need to decompress and compress it again. Any ZipFile metadata is copied and not checked, for example the file CRC.

use std::fs::File;
use std::io::{Read, Seek, Write};
use zip::{ZipArchive, ZipWriter};

fn copy<R, W>(src: &mut ZipArchive<R>, dst: &mut ZipWriter<W>) -> zip::result::ZipResult<()>
where
    R: Read + Seek,
    W: Write + Seek,
{
    // Retrieve file entry by name
    let file = src.by_name("src_file.txt")?;

    // Copy the previously obtained file entry to the destination zip archive
    dst.raw_copy_file(file)?;

    Ok(())
}

pub fn add_directory<S>(
    &mut self,
    name: S,
    options: FileOptions
) -> ZipResult<()> where
    S: Into<String>, 

Add a directory entry.

You can’t write data to the file afterwards.

pub fn add_directory_from_path(
    &mut self,
    path: &Path,
    options: FileOptions
) -> ZipResult<()>

👎 Deprecated since 0.5.7:

by stripping ..s from the path, the meaning of paths can change. Use add_directory instead.

Add a directory entry, taking a Path as argument.

This function ensures that the ‘/’ path seperator is used. It also ignores all non ‘Normal’ Components, such as a starting ‘/’ or ‘..’ and ‘.’.

pub fn finish(&mut self) -> ZipResult<W>

Finish the last file and write all other zip-structures

This will return the writer, but one should normally not append any data to the end of the file. Note that the zipfile will also be finished on drop.

Trait Implementations

impl<W: Write + Seek> Drop for ZipWriter<W>

fn drop(&mut self)

Executes the destructor for this type.

impl<W: Write + Seek> Write for ZipWriter<W>

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

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

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

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

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

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

pub 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.

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

Attempts to write an entire buffer into this writer.

pub 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.

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

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

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

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