# [−][src]Struct deflate::write::ZlibEncoder

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

A Zlib encoder/compressor.

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

# Examples

    use std::io::Write;

    use deflate::Compression;
    use deflate::write::ZlibEncoder;

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

## Methods

### `impl<W: Write> ZlibEncoder<W>`[src]

####
ⓘImportant traits for ZlibEncoder<W>

### Important traits for ZlibEncoder<W>

`impl<W: Write> Write for ZlibEncoder<W>`
`pub fn new<O: Into<CompressionOptions>>(writer: W, options: O) -> ZlibEncoder<W>`[src]

Create a new `ZlibEncoder` using the provided compression options.

#### `pub fn finish(self) -> Result<W>`[src]

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

#### `pub fn reset(&mut self, writer: W) -> Result<W>`[src]

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

#### `pub fn checksum(&self) -> u32`[src]

Return the adler32 checksum of the currently consumed data.

## Trait Implementations

### `impl<W: Write> Drop for ZlibEncoder<W>`[src]

#### `fn drop(&mut self)`[src]

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 ZlibEncoder<W>`[src]

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

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

#### `fn flush(&mut self) -> Result<()>`[src]

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_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>`1.36.0[src]

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

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

Attempts to write an entire buffer into this writer. Read more

#### `fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>`1.0.0[src]

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

#### `fn by_ref(&mut self) -> &mut Self` 1.0.0[src]

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

## Auto Trait Implementations

### `impl<W> Send for ZlibEncoder<W> where
W: Send,`

### `impl<W> Unpin for ZlibEncoder<W> where
W: Unpin,`

### `impl<W> Sync for ZlibEncoder<W> where
W: Sync,`

### `impl<W> UnwindSafe for ZlibEncoder<W> where
W: UnwindSafe,`

### `impl<W> RefUnwindSafe for ZlibEncoder<W> where
W: RefUnwindSafe,`

## Blanket Implementations

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<W> WriteBytesExt for W where
W: Write + ?Sized,` [src]

#### `fn write_u8(&mut self, n: u8) -> Result<(), Error>`[src]

Writes an unsigned 8 bit integer to the underlying writer. Read more

#### `fn write_i8(&mut self, n: i8) -> Result<(), Error>`[src]

Writes a signed 8 bit integer to the underlying writer. Read more

#### `fn write_u16<T>(&mut self, n: u16) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned 16 bit integer to the underlying writer. Read more

#### `fn write_i16<T>(&mut self, n: i16) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed 16 bit integer to the underlying writer. Read more

#### `fn write_u24<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned 24 bit integer to the underlying writer. Read more

#### `fn write_i24<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed 24 bit integer to the underlying writer. Read more

#### `fn write_u32<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned 32 bit integer to the underlying writer. Read more

#### `fn write_i32<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed 32 bit integer to the underlying writer. Read more

#### `fn write_u48<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned 48 bit integer to the underlying writer. Read more

#### `fn write_i48<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed 48 bit integer to the underlying writer. Read more

#### `fn write_u64<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned 64 bit integer to the underlying writer. Read more

#### `fn write_i64<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed 64 bit integer to the underlying writer. Read more

#### `fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned 128 bit integer to the underlying writer.

#### `fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed 128 bit integer to the underlying writer.

#### `fn write_uint<T>(&mut self, n: u64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned n-bytes integer to the underlying writer. Read more

#### `fn write_int<T>(&mut self, n: i64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed n-bytes integer to the underlying writer. Read more

#### `fn write_uint128<T>(&mut self, n: u128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes an unsigned n-bytes integer to the underlying writer. Read more

#### `fn write_int128<T>(&mut self, n: i128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a signed n-bytes integer to the underlying writer. Read more

#### `fn write_f32<T>(&mut self, n: f32) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a IEEE754 single-precision (4 bytes) floating point number to the underlying writer. Read more

#### `fn write_f64<T>(&mut self, n: f64) -> Result<(), Error> where
T: ByteOrder,` [src]

Writes a IEEE754 double-precision (8 bytes) floating point number to the underlying writer. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)