Struct flate2::bufread::DeflateEncoder

pub struct DeflateEncoder<R: BufRead> {
    // some fields omitted
}

A DEFLATE encoder, or compressor.

This structure implements a BufRead interface and will read uncompressed data from an underlying stream and emit a stream of compressed data.

Methods

impl<R: BufRead> EncoderReaderBuf<R>

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

Creates a new encoder which will read uncompressed data from the given stream and emit the compressed stream.

fn reset(&mut self, r: R) -> R

Resets the state of this encoder entirely, swapping out the input stream for another.

This function will reset the internal state of this encoder and replace the input stream with the one provided, returning the previous input stream. Future data read from this encoder will be the compressed version of r's data.

fn get_ref(&self) -> &R

Acquires a reference to the underlying reader

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

Acquires a mutable reference to the underlying stream

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

fn into_inner(self) -> R

Consumes this encoder, returning the underlying reader.

Trait Implementations

impl<R: BufRead> Read for EncoderReaderBuf<R>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chars(self) -> Chars<Self>

Unstable (io)

: the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an Iterator over chars.

fn chain<R>(self, next: R) -> Chain<Self, R> where R: Read

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.