diff options
Diffstat (limited to 'vendor/flate2/src/gz/read.rs')
| -rw-r--r-- | vendor/flate2/src/gz/read.rs | 378 |
1 files changed, 0 insertions, 378 deletions
diff --git a/vendor/flate2/src/gz/read.rs b/vendor/flate2/src/gz/read.rs deleted file mode 100644 index 9dbadbd..0000000 --- a/vendor/flate2/src/gz/read.rs +++ /dev/null @@ -1,378 +0,0 @@ -use std::io; -use std::io::prelude::*; - -use super::bufread; -use super::{GzBuilder, GzHeader}; -use crate::bufreader::BufReader; -use crate::Compression; - -/// A gzip streaming encoder -/// -/// 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::GzEncoder; -/// -/// // Return a vector containing the GZ compressed version of hello world -/// -/// fn gzencode_hello_world() -> io::Result<Vec<u8>> { -/// let mut ret_vec = Vec::new(); -/// let bytestring = b"hello world"; -/// let mut gz = GzEncoder::new(&bytestring[..], Compression::fast()); -/// gz.read_to_end(&mut ret_vec)?; -/// Ok(ret_vec) -/// } -/// ``` -#[derive(Debug)] -pub struct GzEncoder<R> { - inner: bufread::GzEncoder<BufReader<R>>, -} - -pub fn gz_encoder<R: Read>(inner: bufread::GzEncoder<BufReader<R>>) -> GzEncoder<R> { - GzEncoder { inner } -} - -impl<R: Read> GzEncoder<R> { - /// Creates a new encoder which will use the given compression level. - /// - /// The encoder is not configured specially for the emitted header. For - /// header configuration, see the `GzBuilder` type. - /// - /// The data read from the stream `r` will be compressed and available - /// through the returned reader. - pub fn new(r: R, level: Compression) -> GzEncoder<R> { - GzBuilder::new().read(r, level) - } -} - -impl<R> GzEncoder<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 reader. - /// - /// Note that mutation of the reader 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() - } - - /// Returns the underlying stream, consuming this encoder - pub fn into_inner(self) -> R { - self.inner.into_inner().into_inner() - } -} - -impl<R: Read> Read for GzEncoder<R> { - fn read(&mut self, into: &mut [u8]) -> io::Result<usize> { - self.inner.read(into) - } -} - -impl<R: Read + Write> Write for GzEncoder<R> { - 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 decoder for a single member of a [gzip file]. -/// -/// This structure implements a [`Read`] interface. When read from, it reads -/// compressed data from the underlying [`Read`] and provides the uncompressed data. -/// -/// After reading a single member of the gzip data this reader will return -/// Ok(0) even if there are more bytes available in the underlying reader. -/// `GzDecoder` may have read additional bytes past the end of the gzip data. -/// If you need the following bytes, wrap the `Reader` in a `std::io::BufReader` -/// and use `bufread::GzDecoder` instead. -/// -/// To handle gzip files that may have multiple members, see [`MultiGzDecoder`] -/// or read more -/// [in the introduction](../index.html#about-multi-member-gzip-files). -/// -/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5 -/// -/// # Examples -/// -/// ``` -/// use std::io::prelude::*; -/// use std::io; -/// # use flate2::Compression; -/// # use flate2::write::GzEncoder; -/// use flate2::read::GzDecoder; -/// -/// # fn main() { -/// # let mut e = GzEncoder::new(Vec::new(), Compression::default()); -/// # e.write_all(b"Hello World").unwrap(); -/// # let bytes = e.finish().unwrap(); -/// # println!("{}", decode_reader(bytes).unwrap()); -/// # } -/// # -/// // Uncompresses a Gz 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 gz = GzDecoder::new(&bytes[..]); -/// let mut s = String::new(); -/// gz.read_to_string(&mut s)?; -/// Ok(s) -/// } -/// ``` -#[derive(Debug)] -pub struct GzDecoder<R> { - inner: bufread::GzDecoder<BufReader<R>>, -} - -impl<R: Read> GzDecoder<R> { - /// Creates a new decoder from the given reader, immediately parsing the - /// gzip header. - pub fn new(r: R) -> GzDecoder<R> { - GzDecoder { - inner: bufread::GzDecoder::new(BufReader::new(r)), - } - } -} - -impl<R> GzDecoder<R> { - /// Returns the header associated with this stream, if it was valid. - pub fn header(&self) -> Option<&GzHeader> { - self.inner.header() - } - - /// Acquires a reference to the underlying reader. - /// - /// Note that the decoder may have read past the end of the gzip data. - /// To prevent this use [`bufread::GzDecoder`] instead. - 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 continues to be used. - /// - /// Note that the decoder may have read past the end of the gzip data. - /// To prevent this use [`bufread::GzDecoder`] instead. - pub fn get_mut(&mut self) -> &mut R { - self.inner.get_mut().get_mut() - } - - /// Consumes this decoder, returning the underlying reader. - /// - /// Note that the decoder may have read past the end of the gzip data. - /// Subsequent reads will skip those bytes. To prevent this use - /// [`bufread::GzDecoder`] instead. - pub fn into_inner(self) -> R { - self.inner.into_inner().into_inner() - } -} - -impl<R: Read> Read for GzDecoder<R> { - fn read(&mut self, into: &mut [u8]) -> io::Result<usize> { - self.inner.read(into) - } -} - -impl<R: Read + Write> Write for GzDecoder<R> { - 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 gzip streaming decoder that decodes a [gzip file] that may have multiple members. -/// -/// This structure implements a [`Read`] interface. When read from, it reads -/// compressed data from the underlying [`Read`] and provides the uncompressed -/// data. -/// -/// A gzip file consists of a series of *members* concatenated one after another. -/// MultiGzDecoder decodes all members of a file and returns Ok(0) once the -/// underlying reader does. -/// -/// To handle members seperately, see [GzDecoder] or read more -/// [in the introduction](../index.html#about-multi-member-gzip-files). -/// -/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5 -/// -/// # Examples -/// -/// ``` -/// use std::io::prelude::*; -/// use std::io; -/// # use flate2::Compression; -/// # use flate2::write::GzEncoder; -/// use flate2::read::MultiGzDecoder; -/// -/// # fn main() { -/// # let mut e = GzEncoder::new(Vec::new(), Compression::default()); -/// # e.write_all(b"Hello World").unwrap(); -/// # let bytes = e.finish().unwrap(); -/// # println!("{}", decode_reader(bytes).unwrap()); -/// # } -/// # -/// // Uncompresses a Gz 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 gz = MultiGzDecoder::new(&bytes[..]); -/// let mut s = String::new(); -/// gz.read_to_string(&mut s)?; -/// Ok(s) -/// } -/// ``` -#[derive(Debug)] -pub struct MultiGzDecoder<R> { - inner: bufread::MultiGzDecoder<BufReader<R>>, -} - -impl<R: Read> MultiGzDecoder<R> { - /// Creates a new decoder from the given reader, immediately parsing the - /// (first) gzip header. If the gzip stream contains multiple members all will - /// be decoded. - pub fn new(r: R) -> MultiGzDecoder<R> { - MultiGzDecoder { - inner: bufread::MultiGzDecoder::new(BufReader::new(r)), - } - } -} - -impl<R> MultiGzDecoder<R> { - /// Returns the current header associated with this stream, if it's valid. - pub fn header(&self) -> Option<&GzHeader> { - self.inner.header() - } - - /// 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 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. - pub fn into_inner(self) -> R { - self.inner.into_inner().into_inner() - } -} - -impl<R: Read> Read for MultiGzDecoder<R> { - fn read(&mut self, into: &mut [u8]) -> io::Result<usize> { - self.inner.read(into) - } -} - -impl<R: Read + Write> Write for MultiGzDecoder<R> { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - self.get_mut().write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.get_mut().flush() - } -} - -#[cfg(test)] -mod tests { - use std::io::{Cursor, ErrorKind, Read, Result, Write}; - - use super::GzDecoder; - - //a cursor turning EOF into blocking errors - #[derive(Debug)] - pub struct BlockingCursor { - pub cursor: Cursor<Vec<u8>>, - } - - impl BlockingCursor { - pub fn new() -> BlockingCursor { - BlockingCursor { - cursor: Cursor::new(Vec::new()), - } - } - - pub fn set_position(&mut self, pos: u64) { - return self.cursor.set_position(pos); - } - } - - impl Write for BlockingCursor { - fn write(&mut self, buf: &[u8]) -> Result<usize> { - return self.cursor.write(buf); - } - fn flush(&mut self) -> Result<()> { - return self.cursor.flush(); - } - } - - impl Read for BlockingCursor { - fn read(&mut self, buf: &mut [u8]) -> Result<usize> { - //use the cursor, except it turns eof into blocking error - let r = self.cursor.read(buf); - match r { - Err(ref err) => { - if err.kind() == ErrorKind::UnexpectedEof { - return Err(ErrorKind::WouldBlock.into()); - } - } - Ok(0) => { - //regular EOF turned into blocking error - return Err(ErrorKind::WouldBlock.into()); - } - Ok(_n) => {} - } - return r; - } - } - - #[test] - fn blocked_partial_header_read() { - // this is a reader which receives data afterwards - let mut r = BlockingCursor::new(); - let data = vec![1, 2, 3]; - - match r.write_all(&data) { - Ok(()) => {} - _ => { - panic!("Unexpected result for write_all"); - } - } - r.set_position(0); - - // this is unused except for the buffering - let mut decoder = GzDecoder::new(r); - let mut out = Vec::with_capacity(7); - match decoder.read(&mut out) { - Err(e) => { - assert_eq!(e.kind(), ErrorKind::WouldBlock); - } - _ => { - panic!("Unexpected result for decoder.read"); - } - } - } -} |