diff options
Diffstat (limited to 'vendor/flate2/src/deflate/read.rs')
| -rw-r--r-- | vendor/flate2/src/deflate/read.rs | 241 |
1 files changed, 0 insertions, 241 deletions
diff --git a/vendor/flate2/src/deflate/read.rs b/vendor/flate2/src/deflate/read.rs deleted file mode 100644 index 2b6b8f2..0000000 --- a/vendor/flate2/src/deflate/read.rs +++ /dev/null @@ -1,241 +0,0 @@ -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<Vec<u8>> { -/// 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<R> { - inner: bufread::DeflateEncoder<BufReader<R>>, -} - -impl<R: Read> DeflateEncoder<R> { - /// 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<R> { - DeflateEncoder { - inner: bufread::DeflateEncoder::new(BufReader::new(r), level), - } - } -} - -impl<R> DeflateEncoder<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. - /// - /// 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<R: Read> Read for DeflateEncoder<R> { - fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { - self.inner.read(buf) - } -} - -impl<W: Read + Write> Write for DeflateEncoder<W> { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - 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<u8>) -> io::Result<String> { -/// let mut deflater = DeflateDecoder::new(&bytes[..]); -/// let mut s = String::new(); -/// deflater.read_to_string(&mut s)?; -/// Ok(s) -/// } -/// ``` -#[derive(Debug)] -pub struct DeflateDecoder<R> { - inner: bufread::DeflateDecoder<BufReader<R>>, -} - -impl<R: Read> DeflateDecoder<R> { - /// Creates a new decoder which will decompress data read from the given - /// stream. - pub fn new(r: R) -> DeflateDecoder<R> { - 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<u8>) -> DeflateDecoder<R> { - DeflateDecoder { - inner: bufread::DeflateDecoder::new(BufReader::with_buf(buf, r)), - } - } -} - -impl<R> DeflateDecoder<R> { - /// 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<R: Read> Read for DeflateDecoder<R> { - fn read(&mut self, into: &mut [u8]) -> io::Result<usize> { - self.inner.read(into) - } -} - -impl<W: Read + Write> Write for DeflateDecoder<W> { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - self.get_mut().write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.get_mut().flush() - } -} |