Struct deflate::write::GzEncoder

pub struct GzEncoder<W: Write> { /* fields omitted */ }

A Gzip encoder/compressor.

A struct implementing a Write interface that takes unencoded data and compresses it to the provided writer using DEFLATE compression with Gzip headers and trailers.

Examples

use std::io::Write;

use deflate::Compression;
use deflate::write::GzEncoder;

let data = b"This is some test data";
let mut encoder = GzEncoder::new(Vec::new(), Compression::Default);
encoder.write_all(data)?;
let compressed_data = encoder.finish()?;

Methods

impl<W: Write> GzEncoder<W>

fn new<O: Into<CompressionOptions>>(writer: W, options: O) -> GzEncoder<W>

Create a new GzEncoder writing deflate-compressed data to the underlying writer when written to, wrapped in a gzip header and trailer. The header details will be blank.

fn from_builder<O: Into<CompressionOptions>>(
    builder: GzBuilder,
    writer: W,
    options: O
) -> GzEncoder<W>

Create a new GzEncoder from the provided GzBuilder. This allows customising the detalis of the header, such as the filename and comment fields.

fn finish(self) -> Result<W>

Encode all pending data to the contained writer, consume this GzEncoder, and return the contained writer if writing succeeds.

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

Resets the encoder (except the compression options), replacing the current writer with a new one, returning the old one. (Using a blank header).

fn reset_with_builder(&mut self, writer: W, builder: GzBuilder) -> Result<W>

Resets the encoder (excelt the compression options), replacing the current writer with a new one, returning the old one, and using the provided GzBuilder to create the header.

fn checksum(&self) -> u32

Get the crc32 checksum of the data comsumed so far.

Trait Implementations

impl<W: Write> Write for GzEncoder<W>

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

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

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

Flush the encoder.

This will flush the encoder, emulating the Sync flush method from Zlib. This essentially finishes the current block, and sends an additional empty stored block to the writer.

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

Attempts to write an entire buffer into this write.

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

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

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

Creates a "by reference" adaptor for this instance of Write.

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

fn drop(&mut self)

When the encoder is dropped, output the rest of the data.

WARNING: This may silently fail if writing fails, so using this to finish encoding for writers where writing might fail is not recommended, for that call finish() instead.