Initial vendor packages
Signed-off-by: Valentin Popov <valentin@popov.link>
This commit is contained in:
241
vendor/flate2/src/deflate/read.rs
vendored
Normal file
241
vendor/flate2/src/deflate/read.rs
vendored
Normal file
@ -0,0 +1,241 @@
|
||||
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()
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user