Struct `ZlibDecoder`

struct ZlibDecoder<W: Write> { ... }

A ZLIB decoder, or decompressor.

This structure implements a Write and will emit a stream of decompressed data when fed a stream of compressed data.

After decoding a single member of the ZLIB data this writer will return the number of bytes up to the end of the ZLIB member and subsequent writes will return Ok(0) allowing the caller to handle any data following the ZLIB member.

Examples

use std::io::prelude::*;
use std::io;
# use flate2::Compression;
# use flate2::write::ZlibEncoder;
use flate2::write::ZlibDecoder;

# fn main() {
#    let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
#    e.write_all(b"Hello World").unwrap();
#    let bytes = e.finish().unwrap();
#    println!("{}", decode_reader(bytes).unwrap());
# }
#
// Uncompresses a Zlib Encoded vector of bytes and returns a string or error
// Here Vec<u8> implements Write

fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
   let mut writer = Vec::new();
   let mut z = ZlibDecoder::new(writer);
   z.write_all(&bytes[..])?;
   writer = z.finish()?;
   let return_string = String::from_utf8(writer).expect("String parsing error");
   Ok(return_string)
}

Implementations

`impl<W: Write> ZlibDecoder<W>`

fn new(w: W) -> ZlibDecoder<W>

Creates a new decoder which will write uncompressed data to the stream.

When this decoder is dropped or unwrapped the final pieces of data will be flushed.

fn new_with_decompress(w: W, decompression: Decompress) -> ZlibDecoder<W>

Creates a new decoder which will write uncompressed data to the stream w using the given decompression settings.

When this decoder is dropped or unwrapped the final pieces of data will be flushed.

fn get_ref(self: &Self) -> &W

Acquires a reference to the underlying writer.

fn get_mut(self: &mut Self) -> &mut W

Acquires a mutable reference to the underlying writer.

Note that mutating the output/input state of the stream may corrupt this object, so care must be taken when using this method.

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

Resets the state of this decoder entirely, swapping out the output stream for another.

This will reset the internal state of this decoder and replace the output stream with the one provided, returning the previous output stream. Future data written to this decoder will be decompressed into the output stream w.

Errors

This function will perform I/O to complete this stream, and any I/O errors which occur will be returned from this function.

fn try_finish(self: &mut Self) -> Result<()>

Attempt to finish this output stream, writing out final chunks of data.

Note that this function can only be used once data has finished being written to the output stream. After this function is called then further calls to write may result in a panic.

Panics

Attempts to write data to this stream may result in a panic after this function is called.

Errors

This function will perform I/O to complete this stream, and any I/O errors which occur will be returned from this function.

fn finish(self: Self) -> Result<W>

Consumes this encoder, flushing the output stream.

This will flush the underlying data stream and then return the contained writer if the flush succeeded.

Note that this function may not be suitable to call in a situation where the underlying stream is an asynchronous I/O stream. To finish a stream the try_finish (or shutdown) method should be used instead. To re-acquire ownership of a stream it is safe to call this method after try_finish or shutdown has returned Ok.

Errors

This function will perform I/O to complete this stream, and any I/O errors which occur will be returned from this function.

fn total_in(self: &Self) -> u64

Returns the number of bytes that the decompressor has consumed for decompression.

Note that this will likely be smaller than the number of bytes successfully written to this stream due to internal buffering.

fn total_out(self: &Self) -> u64

Returns the number of bytes that the decompressor has written to its output stream.

`impl<T> Any for ZlibDecoder<W>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for ZlibDecoder<W>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for ZlibDecoder<W>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for ZlibDecoder<W>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for ZlibDecoder<W>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for ZlibDecoder<W>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for ZlibDecoder<W>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<W> Freeze for ZlibDecoder<W>`

`impl<W> RefUnwindSafe for ZlibDecoder<W>`

`impl<W> Send for ZlibDecoder<W>`

`impl<W> Sync for ZlibDecoder<W>`

`impl<W> Unpin for ZlibDecoder<W>`

`impl<W> UnsafeUnpin for ZlibDecoder<W>`

`impl<W> UnwindSafe for ZlibDecoder<W>`

`impl<W: $crate::fmt::Debug + Write> Debug for ZlibDecoder<W>`

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

`impl<W: Read + Write> Read for ZlibDecoder<W>`

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

`impl<W: Write> Write for ZlibDecoder<W>`

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