Struct `GzEncoder`

struct GzEncoder<R> { ... }

A gzip streaming encoder

This structure implements a Read interface. When read from, it reads uncompressed data from the underlying BufRead and provides the compressed data.

Examples

use std::io::prelude::*;
use std::io;
use flate2::Compression;
use flate2::bufread::GzEncoder;
use std::fs::File;
use std::io::BufReader;

// Opens sample file, compresses the contents and returns a Vector or error
// File wrapped in a BufReader implements BufRead

fn open_hello_world() -> io::Result<Vec<u8>> {
    let f = File::open("examples/hello_world.txt")?;
    let b = BufReader::new(f);
    let mut gz = GzEncoder::new(b, Compression::fast());
    let mut buffer = Vec::new();
    gz.read_to_end(&mut buffer)?;
    Ok(buffer)
}

Implementations

`impl<R> GzEncoder<R>`

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

Acquires a reference to the underlying reader.

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

Acquires a mutable reference to the underlying reader.

Note that mutation of the reader may result in surprising results if this encoder is continued to be used.

fn into_inner(self: Self) -> R

Returns the underlying stream, consuming this encoder

`impl<R: BufRead> GzEncoder<R>`

fn new(r: R, level: Compression) -> GzEncoder<R>

Creates a new encoder which will use the given compression level.

The encoder is not configured specially for the emitted header. For header configuration, see the GzBuilder type.

The data read from the stream r will be compressed and available through the returned reader.

`impl<R> Freeze for GzEncoder<R>`

`impl<R> RefUnwindSafe for GzEncoder<R>`

`impl<R> Send for GzEncoder<R>`

`impl<R> Sync for GzEncoder<R>`

`impl<R> Unpin for GzEncoder<R>`

`impl<R> UnsafeUnpin for GzEncoder<R>`

`impl<R> UnwindSafe for GzEncoder<R>`

`impl<R: $crate::fmt::Debug> Debug for GzEncoder<R>`

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

`impl<R: BufRead + Write> Write for GzEncoder<R>`

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

`impl<R: BufRead> Read for GzEncoder<R>`

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

`impl<T> Any for GzEncoder<R>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for GzEncoder<R>`

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

`impl<T> BorrowMut for GzEncoder<R>`

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

`impl<T> From for GzEncoder<R>`

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

`impl<T, U> Into for GzEncoder<R>`

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 GzEncoder<R>`

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

`impl<T, U> TryInto for GzEncoder<R>`

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