Struct deflate::write::DeflateEncoder

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

[−] Expand description

A DEFLATE encoder/compressor.

A struct implementing a Write interface that takes arbitrary data and compresses it to the provided writer using DEFLATE compression.

Examples

use std::io::Write;

use deflate::Compression;
use deflate::write::DeflateEncoder;

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

Implementations

impl<W: Write> DeflateEncoder<W>[−]

pub fn new<O: Into<CompressionOptions>>(
    writer: W,
    options: O
) -> DeflateEncoder<W>[−]

Creates a new encoder using the provided compression options.

pub fn finish(self) -> Result<W>[−]

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

pub fn reset(&mut self, w: W) -> Result<W>[−]

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

Trait Implementations

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

impl<W: Write> Write for DeflateEncoder<W>[+]

[+] Show hidden undocumented items

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

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.