Struct flate2::bufread::GzDecoder

pub struct GzDecoder<R> { /* fields omitted */ }

A gzip streaming decoder

This structure exposes a ReadBuf interface that will consume compressed data from the underlying reader and emit uncompressed data.

Examples

use std::io::prelude::*;
use std::io;
use flate2::bufread::GzDecoder;

// Uncompresses a Gz Encoded vector of bytes and returns a string or error
// Here &[u8] implements BufRead

fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
   let mut gz = GzDecoder::new(&bytes[..])?;
   let mut s = String::new();
   gz.read_to_string(&mut s)?;
   Ok(s)
}

Methods

impl<R: BufRead> GzDecoder<R>

fn new(r: R) -> Result<GzDecoder<R>>

Creates a new decoder from the given reader, immediately parsing the gzip header.

Errors

If an error is encountered when parsing the gzip header, an error is returned.

impl<R> GzDecoder<R>

fn header(&self) -> &Header

Returns the header associated with this stream.

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 decoder, returning the underlying reader.

Trait Implementations

impl<R: Debug> Debug for GzDecoder<R>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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

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

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

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

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>

🔬 This is a nightly-only experimental API. (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 [char]s.

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.

impl<R: BufRead + Write> Write for GzDecoder<R>

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

Write a buffer into this object, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

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

Attempts to write an entire buffer into this write.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

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

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

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