Struct Reader

pub struct Reader<Input: BufRead> { /* private fields */ }

Reader uncompress data provided by another reader (input source). Reader returns Ok(0) after the final block in the DEFLATE stream has been encountered. Any trailing data after the final block is ignored.

The input source must be buffered because the implementation uses many 1-byte reads.

Implementations

impl<'a, Input: BufRead> Reader<Input>

pub fn new(r: Input) -> Reader<Input>

new returns a new Reader that can be used to read the uncompressed version of r. The reader returns std::io::Error::EOF after the final block in the DEFLATE stream has been encountered. Any trailing data after the final block is ignored.

pub fn new_dict(r: Input, dict: &'a [u8]) -> Reader<Input>

new_dict is like new but initializes the reader with a preset dictionary. The returned Reader behaves as if the uncompressed data stream started with the given dictionary, which has already been read. new_dict is typically used to read data compressed by Writer::new_dict.

Examples found in repository

examples/flate-dict.rs (line 50)

fn example_dictionary() {
    // The dictionary is a string of bytes. When compressing some input data,
    // the compressor will attempt to substitute substrings with matches found
    // in the dictionary. As such, the dictionary should only contain substrings
    // that are expected to be found in the actual data stream.
    let dict = b"<?xml version=\"1.0\"?><book><data><meta name=\"\" content=\"";

    // The data to compress should (but is not required to) contain frequent
    // substrings that match those in the dictionary.
    let data = r#"<?xml version="1.0"?>
<book>
    <meta name="title" content="The Go Programming Language"/>
    <meta name="authors" content="Alan Donovan and Brian Kernighan"/>
    <meta name="published" content="2015-10-26"/>
    <meta name="isbn" content="978-0134190440"/>
    <data>...</data>
</book>
"#;

    let mut b = bytes::Buffer::new();

    // Compress the data using the specially crafted dictionary.
    {
        let mut zw = flate::Writer::new_dict(&mut b, flate::DEFAULT_COMPRESSION, dict).unwrap();
        let mut data_reader = bytes::new_buffer_string(data);
        std::io::copy(&mut data_reader, &mut zw).unwrap();
        zw.close().unwrap();
    }

    // The decompressor must use the same dictionary as the compressor.
    // Otherwise, the input may appear as corrupted.
    println!("Decompressed output using the dictionary:");
    {
        let mut data_reader = b.bytes();
        let mut zr = flate::Reader::new_dict(&mut data_reader, dict);
        let mut decompressed = bytes::Buffer::new();
        std::io::copy(&mut zr, &mut decompressed).unwrap();
        zr.close().unwrap();
        println!("{}", String::from_utf8_lossy(decompressed.bytes()));
        println!();
    }

    // Substitute all of the bytes in the dictionary with a '#' to visually
    // demonstrate the approximate effectiveness of using a preset dictionary.
    println!("Substrings matched by the dictionary are marked with #:");
    {
        let hash_dict = vec![b'#'; dict.len()];
        let mut zr = flate::Reader::new_dict(&mut b, &hash_dict);
        let mut decompressed = bytes::Buffer::new();
        std::io::copy(&mut zr, &mut decompressed).unwrap();
        zr.close().unwrap();
        println!("{}", String::from_utf8_lossy(decompressed.bytes()));
    }

    // Output:
    // Decompressed output using the dictionary:
    // <?xml version="1.0"?>
    // <book>
    // 	<meta name="title" content="The Go Programming Language"/>
    // 	<meta name="authors" content="Alan Donovan and Brian Kernighan"/>
    // 	<meta name="published" content="2015-10-26"/>
    // 	<meta name="isbn" content="978-0134190440"/>
    // 	<data>...</data>
    // </book>
    //
    // Substrings matched by the dictionary are marked with #:
    // #####################
    // ######
    // 	############title###########The Go Programming Language"/#
    // 	############authors###########Alan Donovan and Brian Kernighan"/#
    // 	############published###########2015-10-26"/#
    // 	############isbn###########978-0134190440"/#
    // 	######...</#####
    // </#####
}

pub fn close(&mut self) -> Result<()>

Examples found in repository

examples/flate-dict.rs (line 53)

fn example_dictionary() {
    // The dictionary is a string of bytes. When compressing some input data,
    // the compressor will attempt to substitute substrings with matches found
    // in the dictionary. As such, the dictionary should only contain substrings
    // that are expected to be found in the actual data stream.
    let dict = b"<?xml version=\"1.0\"?><book><data><meta name=\"\" content=\"";

    // The data to compress should (but is not required to) contain frequent
    // substrings that match those in the dictionary.
    let data = r#"<?xml version="1.0"?>
<book>
    <meta name="title" content="The Go Programming Language"/>
    <meta name="authors" content="Alan Donovan and Brian Kernighan"/>
    <meta name="published" content="2015-10-26"/>
    <meta name="isbn" content="978-0134190440"/>
    <data>...</data>
</book>
"#;

    let mut b = bytes::Buffer::new();

    // Compress the data using the specially crafted dictionary.
    {
        let mut zw = flate::Writer::new_dict(&mut b, flate::DEFAULT_COMPRESSION, dict).unwrap();
        let mut data_reader = bytes::new_buffer_string(data);
        std::io::copy(&mut data_reader, &mut zw).unwrap();
        zw.close().unwrap();
    }

    // The decompressor must use the same dictionary as the compressor.
    // Otherwise, the input may appear as corrupted.
    println!("Decompressed output using the dictionary:");
    {
        let mut data_reader = b.bytes();
        let mut zr = flate::Reader::new_dict(&mut data_reader, dict);
        let mut decompressed = bytes::Buffer::new();
        std::io::copy(&mut zr, &mut decompressed).unwrap();
        zr.close().unwrap();
        println!("{}", String::from_utf8_lossy(decompressed.bytes()));
        println!();
    }

    // Substitute all of the bytes in the dictionary with a '#' to visually
    // demonstrate the approximate effectiveness of using a preset dictionary.
    println!("Substrings matched by the dictionary are marked with #:");
    {
        let hash_dict = vec![b'#'; dict.len()];
        let mut zr = flate::Reader::new_dict(&mut b, &hash_dict);
        let mut decompressed = bytes::Buffer::new();
        std::io::copy(&mut zr, &mut decompressed).unwrap();
        zr.close().unwrap();
        println!("{}", String::from_utf8_lossy(decompressed.bytes()));
    }

    // Output:
    // Decompressed output using the dictionary:
    // <?xml version="1.0"?>
    // <book>
    // 	<meta name="title" content="The Go Programming Language"/>
    // 	<meta name="authors" content="Alan Donovan and Brian Kernighan"/>
    // 	<meta name="published" content="2015-10-26"/>
    // 	<meta name="isbn" content="978-0134190440"/>
    // 	<data>...</data>
    // </book>
    //
    // Substrings matched by the dictionary are marked with #:
    // #####################
    // ######
    // 	############title###########The Go Programming Language"/#
    // 	############authors###########Alan Donovan and Brian Kernighan"/#
    // 	############published###########2015-10-26"/#
    // 	############isbn###########978-0134190440"/#
    // 	######...</#####
    // </#####
}

pub fn reset(&mut self, r: Input, dict: &[u8])

pub fn reset_state(&mut self, dict: &[u8])

pub fn input_reader(&mut self) -> &mut Input

input_reader returns mutable reference to the underlying reader.

Trait Implementations

impl<Input: BufRead> Read for Reader<Input>

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>

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

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

Reads all bytes until EOF in this source, appending them to buf.

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

Reads 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)

Reads 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.

impl<Input: BufRead> Reader for Reader<Input>

fn read(&mut self, p: &mut [u8]) -> IoRes

read reads up to len(p) bytes into p. It returns the number of bytes read (0 <= n <= len(p)) and any error encountered. Even if read returns n < len(p), it may use all of p as scratch space during the call. If some data is available but not len(p) bytes, read conventionally returns what is available instead of waiting for more.