Struct libflate::zlib::Decoder

pub struct Decoder<R> { /* private fields */ }

ZLIB decoder.

Implementations

impl<R> Decoder<R>

where R: Read,

pub fn new(inner: R) -> Result<Self>

Makes a new decoder instance.

inner is to be decoded ZLIB stream.

Examples

use core2::io::Read;
use libflate::zlib::Decoder;

let encoded_data = [120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47,
                    202, 73, 81, 4, 0, 28, 73, 4, 62];

let mut decoder = Decoder::new(&encoded_data[..]).unwrap();
let mut buf = Vec::new();
decoder.read_to_end(&mut buf).unwrap();

assert_eq!(buf, b"Hello World!");

pub fn header(&self) -> &Header

Returns the header of the ZLIB stream.

Examples

use libflate::zlib::{Decoder, CompressionLevel};

let encoded_data = [120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47,
                    202, 73, 81, 4, 0, 28, 73, 4, 62];

let decoder = Decoder::new(&encoded_data[..]).unwrap();
assert_eq!(decoder.header().compression_level(),
           CompressionLevel::Default);

pub fn as_inner_ref(&self) -> &R

Returns the immutable reference to the inner stream.

pub fn as_inner_mut(&mut self) -> &mut R

Returns the mutable reference to the inner stream.

pub fn into_inner(self) -> R

Unwraps this Decoder, returning the underlying reader.

Examples

use core2::io::Cursor;
use libflate::zlib::Decoder;

let encoded_data = [120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47,
                    202, 73, 81, 4, 0, 28, 73, 4, 62];

let decoder = Decoder::new(Cursor::new(&encoded_data)).unwrap();
assert_eq!(decoder.into_inner().into_inner(), &encoded_data);

pub fn unread_decoded_data(&self) -> &[u8]

Returns the data that has been decoded but has not yet been read.

This method is useful to retrieve partial decoded data when the decoding process is failed.

Trait Implementations

impl<R: Debug> Debug for Decoder<R>

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

Formats the value using the given formatter.

impl<R> Read for Decoder<R>

where R: Read,

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_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

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, appending them to buf.

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

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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