crates/flate2/src/gz/read.rs - platform/external/rust/android-crates-io - Git at Google

 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");
             }
         }
     }
 }
	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");
	}
	}
	}
	}