use std::io; use std::io::prelude::*; use super::bufread; use crate::bufreader::BufReader; /// A DEFLATE encoder, or compressor. /// /// This structure implements a [`Read`] interface. When read from, it reads /// uncompressed data from the underlying [`Read`] and provides the compressed data. /// /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html /// /// # Examples /// /// ``` /// use std::io::prelude::*; /// use std::io; /// use flate2::Compression; /// use flate2::read::DeflateEncoder; /// /// # fn main() { /// # println!("{:?}", deflateencoder_read_hello_world().unwrap()); /// # } /// # /// // Return a vector containing the Deflate compressed version of hello world /// fn deflateencoder_read_hello_world() -> io::Result> { /// let mut ret_vec = Vec::new(); /// let c = b"hello world"; /// let mut deflater = DeflateEncoder::new(&c[..], Compression::fast()); /// deflater.read_to_end(&mut ret_vec)?; /// Ok(ret_vec) /// } /// ``` #[derive(Debug)] pub struct DeflateEncoder { inner: bufread::DeflateEncoder>, } impl DeflateEncoder { /// Creates a new encoder which will read uncompressed data from the given /// stream and emit the compressed stream. pub fn new(r: R, level: crate::Compression) -> DeflateEncoder { DeflateEncoder { inner: bufread::DeflateEncoder::new(BufReader::new(r), level), } } } impl DeflateEncoder { /// 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. /// /// Note that there may be currently buffered data when this function is /// called, and in that case the buffered data is discarded. pub fn reset(&mut self, r: R) -> R { super::bufread::reset_encoder_data(&mut self.inner); self.inner.get_mut().reset(r) } /// Acquires a reference to the underlying reader pub fn get_ref(&self) -> &R { self.inner.get_ref().get_ref() } /// 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. pub fn get_mut(&mut self) -> &mut R { self.inner.get_mut().get_mut() } /// Consumes this encoder, returning the underlying reader. /// /// Note that there may be buffered bytes which are not re-acquired as part /// of this transition. It's recommended to only call this function after /// EOF has been reached. pub fn into_inner(self) -> R { self.inner.into_inner().into_inner() } /// Returns the number of bytes that have been read into this compressor. /// /// Note that not all bytes read from the underlying object may be accounted /// for, there may still be some active buffering. pub fn total_in(&self) -> u64 { self.inner.total_in() } /// Returns the number of bytes that the compressor has produced. /// /// Note that not all bytes may have been read yet, some may still be /// buffered. pub fn total_out(&self) -> u64 { self.inner.total_out() } } impl Read for DeflateEncoder { fn read(&mut self, buf: &mut [u8]) -> io::Result { self.inner.read(buf) } } impl Write for DeflateEncoder { fn write(&mut self, buf: &[u8]) -> io::Result { self.get_mut().write(buf) } fn flush(&mut self) -> io::Result<()> { self.get_mut().flush() } } /// A DEFLATE decoder, or decompressor. /// /// This structure implements a [`Read`] interface. When read from, it reads /// compressed data from the underlying [`Read`] and provides the uncompressed data. /// /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html /// /// # Examples /// /// ``` /// use std::io::prelude::*; /// use std::io; /// # use flate2::Compression; /// # use flate2::write::DeflateEncoder; /// use flate2::read::DeflateDecoder; /// /// # fn main() { /// # let mut e = DeflateEncoder::new(Vec::new(), Compression::default()); /// # e.write_all(b"Hello World").unwrap(); /// # let bytes = e.finish().unwrap(); /// # println!("{}", decode_reader(bytes).unwrap()); /// # } /// // Uncompresses a Deflate Encoded vector of bytes and returns a string or error /// // Here &[u8] implements Read /// fn decode_reader(bytes: Vec) -> io::Result { /// let mut deflater = DeflateDecoder::new(&bytes[..]); /// let mut s = String::new(); /// deflater.read_to_string(&mut s)?; /// Ok(s) /// } /// ``` #[derive(Debug)] pub struct DeflateDecoder { inner: bufread::DeflateDecoder>, } impl DeflateDecoder { /// Creates a new decoder which will decompress data read from the given /// stream. pub fn new(r: R) -> DeflateDecoder { DeflateDecoder::new_with_buf(r, vec![0; 32 * 1024]) } /// Same as `new`, but the intermediate buffer for data is specified. /// /// Note that the capacity of the intermediate buffer is never increased, /// and it is recommended for it to be large. pub fn new_with_buf(r: R, buf: Vec) -> DeflateDecoder { DeflateDecoder { inner: bufread::DeflateDecoder::new(BufReader::with_buf(buf, r)), } } } impl DeflateDecoder { /// Resets the state of this decoder entirely, swapping out the input /// stream for another. /// /// This will reset the internal state of this decoder and replace the /// input stream with the one provided, returning the previous input /// stream. Future data read from this decoder will be the decompressed /// version of `r`'s data. /// /// Note that there may be currently buffered data when this function is /// called, and in that case the buffered data is discarded. pub fn reset(&mut self, r: R) -> R { super::bufread::reset_decoder_data(&mut self.inner); self.inner.get_mut().reset(r) } /// Acquires a reference to the underlying stream pub fn get_ref(&self) -> &R { self.inner.get_ref().get_ref() } /// Acquires a mutable reference to the underlying stream /// /// Note that mutation of the stream may result in surprising results if /// this decoder is continued to be used. pub fn get_mut(&mut self) -> &mut R { self.inner.get_mut().get_mut() } /// Consumes this decoder, returning the underlying reader. /// /// Note that there may be buffered bytes which are not re-acquired as part /// of this transition. It's recommended to only call this function after /// EOF has been reached. pub fn into_inner(self) -> R { self.inner.into_inner().into_inner() } /// Returns the number of bytes that the decompressor has consumed. /// /// Note that this will likely be smaller than what the decompressor /// actually read from the underlying stream due to buffering. pub fn total_in(&self) -> u64 { self.inner.total_in() } /// Returns the number of bytes that the decompressor has produced. pub fn total_out(&self) -> u64 { self.inner.total_out() } } impl Read for DeflateDecoder { fn read(&mut self, into: &mut [u8]) -> io::Result { self.inner.read(into) } } impl Write for DeflateDecoder { fn write(&mut self, buf: &[u8]) -> io::Result { self.get_mut().write(buf) } fn flush(&mut self) -> io::Result<()> { self.get_mut().flush() } }