diff options
Diffstat (limited to 'vendor/flate2/src/zlib/write.rs')
| -rw-r--r-- | vendor/flate2/src/zlib/write.rs | 340 |
1 files changed, 0 insertions, 340 deletions
diff --git a/vendor/flate2/src/zlib/write.rs b/vendor/flate2/src/zlib/write.rs deleted file mode 100644 index d8ad2f2..0000000 --- a/vendor/flate2/src/zlib/write.rs +++ /dev/null @@ -1,340 +0,0 @@ -use std::io; -use std::io::prelude::*; - -use crate::zio; -use crate::{Compress, Decompress}; - -/// A ZLIB encoder, or compressor. -/// -/// This structure implements a [`Write`] interface and takes a stream of -/// uncompressed data, writing the compressed data to the wrapped writer. -/// -/// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html -/// -/// # Examples -/// -/// ``` -/// use std::io::prelude::*; -/// use flate2::Compression; -/// use flate2::write::ZlibEncoder; -/// -/// // Vec<u8> implements Write, assigning the compressed bytes of sample string -/// -/// # fn zlib_encoding() -> std::io::Result<()> { -/// let mut e = ZlibEncoder::new(Vec::new(), Compression::default()); -/// e.write_all(b"Hello World")?; -/// let compressed = e.finish()?; -/// # Ok(()) -/// # } -/// ``` -#[derive(Debug)] -pub struct ZlibEncoder<W: Write> { - inner: zio::Writer<W, Compress>, -} - -impl<W: Write> ZlibEncoder<W> { - /// Creates a new encoder which will write compressed data to the stream - /// given at the given compression level. - /// - /// When this encoder is dropped or unwrapped the final pieces of data will - /// be flushed. - pub fn new(w: W, level: crate::Compression) -> ZlibEncoder<W> { - ZlibEncoder { - inner: zio::Writer::new(w, Compress::new(level, true)), - } - } - - /// Creates a new encoder which will write compressed data to the stream - /// `w` with the given `compression` settings. - pub fn new_with_compress(w: W, compression: Compress) -> ZlibEncoder<W> { - ZlibEncoder { - inner: zio::Writer::new(w, compression), - } - } - - /// Acquires a reference to the underlying writer. - pub fn get_ref(&self) -> &W { - self.inner.get_ref() - } - - /// Acquires a mutable reference to the underlying writer. - /// - /// Note that mutating the output/input state of the stream may corrupt this - /// object, so care must be taken when using this method. - pub fn get_mut(&mut self) -> &mut W { - self.inner.get_mut() - } - - /// Resets the state of this encoder entirely, swapping out the output - /// stream for another. - /// - /// This function will finish encoding the current stream into the current - /// output stream before swapping out the two output streams. - /// - /// After the current stream has been finished, this will reset the internal - /// state of this encoder and replace the output stream with the one - /// provided, returning the previous output stream. Future data written to - /// this encoder will be the compressed into the stream `w` provided. - /// - /// # Errors - /// - /// This function will perform I/O to complete this stream, and any I/O - /// errors which occur will be returned from this function. - pub fn reset(&mut self, w: W) -> io::Result<W> { - self.inner.finish()?; - self.inner.data.reset(); - Ok(self.inner.replace(w)) - } - - /// Attempt to finish this output stream, writing out final chunks of data. - /// - /// Note that this function can only be used once data has finished being - /// written to the output stream. After this function is called then further - /// calls to `write` may result in a panic. - /// - /// # Panics - /// - /// Attempts to write data to this stream may result in a panic after this - /// function is called. - /// - /// # Errors - /// - /// This function will perform I/O to complete this stream, and any I/O - /// errors which occur will be returned from this function. - pub fn try_finish(&mut self) -> io::Result<()> { - self.inner.finish() - } - - /// Consumes this encoder, flushing the output stream. - /// - /// This will flush the underlying data stream, close off the compressed - /// stream and, if successful, return the contained writer. - /// - /// Note that this function may not be suitable to call in a situation where - /// the underlying stream is an asynchronous I/O stream. To finish a stream - /// the `try_finish` (or `shutdown`) method should be used instead. To - /// re-acquire ownership of a stream it is safe to call this method after - /// `try_finish` or `shutdown` has returned `Ok`. - /// - /// # Errors - /// - /// This function will perform I/O to complete this stream, and any I/O - /// errors which occur will be returned from this function. - pub fn finish(mut self) -> io::Result<W> { - self.inner.finish()?; - Ok(self.inner.take_inner()) - } - - /// Consumes this encoder, flushing the output stream. - /// - /// This will flush the underlying data stream and then return the contained - /// writer if the flush succeeded. - /// The compressed stream will not closed but only flushed. This - /// means that obtained byte array can by extended by another deflated - /// stream. To close the stream add the two bytes 0x3 and 0x0. - /// - /// # Errors - /// - /// This function will perform I/O to complete this stream, and any I/O - /// errors which occur will be returned from this function. - pub fn flush_finish(mut self) -> io::Result<W> { - self.inner.flush()?; - Ok(self.inner.take_inner()) - } - - /// Returns the number of bytes that have been written to this compressor. - /// - /// Note that not all bytes written to this object may be accounted for, - /// there may still be some active buffering. - pub fn total_in(&self) -> u64 { - self.inner.data.total_in() - } - - /// Returns the number of bytes that the compressor has produced. - /// - /// Note that not all bytes may have been written yet, some may still be - /// buffered. - pub fn total_out(&self) -> u64 { - self.inner.data.total_out() - } -} - -impl<W: Write> Write for ZlibEncoder<W> { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - self.inner.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} - -impl<W: Read + Write> Read for ZlibEncoder<W> { - fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { - self.get_mut().read(buf) - } -} - -/// A ZLIB decoder, or decompressor. -/// -/// This structure implements a [`Write`] and will emit a stream of decompressed -/// data when fed a stream of compressed data. -/// -/// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html -/// -/// # Examples -/// -/// ``` -/// use std::io::prelude::*; -/// use std::io; -/// # use flate2::Compression; -/// # use flate2::write::ZlibEncoder; -/// use flate2::write::ZlibDecoder; -/// -/// # fn main() { -/// # let mut e = ZlibEncoder::new(Vec::new(), Compression::default()); -/// # e.write_all(b"Hello World").unwrap(); -/// # let bytes = e.finish().unwrap(); -/// # println!("{}", decode_reader(bytes).unwrap()); -/// # } -/// # -/// // Uncompresses a Zlib Encoded vector of bytes and returns a string or error -/// // Here Vec<u8> implements Write -/// -/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> { -/// let mut writer = Vec::new(); -/// let mut z = ZlibDecoder::new(writer); -/// z.write_all(&bytes[..])?; -/// writer = z.finish()?; -/// let return_string = String::from_utf8(writer).expect("String parsing error"); -/// Ok(return_string) -/// } -/// ``` -#[derive(Debug)] -pub struct ZlibDecoder<W: Write> { - inner: zio::Writer<W, Decompress>, -} - -impl<W: Write> ZlibDecoder<W> { - /// Creates a new decoder which will write uncompressed data to the stream. - /// - /// When this decoder is dropped or unwrapped the final pieces of data will - /// be flushed. - pub fn new(w: W) -> ZlibDecoder<W> { - ZlibDecoder { - inner: zio::Writer::new(w, Decompress::new(true)), - } - } - - /// Creates a new decoder which will write uncompressed data to the stream `w` - /// using the given `decompression` settings. - /// - /// When this decoder is dropped or unwrapped the final pieces of data will - /// be flushed. - pub fn new_with_decompress(w: W, decompression: Decompress) -> ZlibDecoder<W> { - ZlibDecoder { - inner: zio::Writer::new(w, decompression), - } - } - - /// Acquires a reference to the underlying writer. - pub fn get_ref(&self) -> &W { - self.inner.get_ref() - } - - /// Acquires a mutable reference to the underlying writer. - /// - /// Note that mutating the output/input state of the stream may corrupt this - /// object, so care must be taken when using this method. - pub fn get_mut(&mut self) -> &mut W { - self.inner.get_mut() - } - - /// Resets the state of this decoder entirely, swapping out the output - /// stream for another. - /// - /// This will reset the internal state of this decoder and replace the - /// output stream with the one provided, returning the previous output - /// stream. Future data written to this decoder will be decompressed into - /// the output stream `w`. - /// - /// # Errors - /// - /// This function will perform I/O to complete this stream, and any I/O - /// errors which occur will be returned from this function. - pub fn reset(&mut self, w: W) -> io::Result<W> { - self.inner.finish()?; - self.inner.data = Decompress::new(true); - Ok(self.inner.replace(w)) - } - - /// Attempt to finish this output stream, writing out final chunks of data. - /// - /// Note that this function can only be used once data has finished being - /// written to the output stream. After this function is called then further - /// calls to `write` may result in a panic. - /// - /// # Panics - /// - /// Attempts to write data to this stream may result in a panic after this - /// function is called. - /// - /// # Errors - /// - /// This function will perform I/O to complete this stream, and any I/O - /// errors which occur will be returned from this function. - pub fn try_finish(&mut self) -> io::Result<()> { - self.inner.finish() - } - - /// Consumes this encoder, flushing the output stream. - /// - /// This will flush the underlying data stream and then return the contained - /// writer if the flush succeeded. - /// - /// Note that this function may not be suitable to call in a situation where - /// the underlying stream is an asynchronous I/O stream. To finish a stream - /// the `try_finish` (or `shutdown`) method should be used instead. To - /// re-acquire ownership of a stream it is safe to call this method after - /// `try_finish` or `shutdown` has returned `Ok`. - /// - /// # Errors - /// - /// This function will perform I/O to complete this stream, and any I/O - /// errors which occur will be returned from this function. - pub fn finish(mut self) -> io::Result<W> { - self.inner.finish()?; - Ok(self.inner.take_inner()) - } - - /// Returns the number of bytes that the decompressor has consumed for - /// decompression. - /// - /// Note that this will likely be smaller than the number of bytes - /// successfully written to this stream due to internal buffering. - pub fn total_in(&self) -> u64 { - self.inner.data.total_in() - } - - /// Returns the number of bytes that the decompressor has written to its - /// output stream. - pub fn total_out(&self) -> u64 { - self.inner.data.total_out() - } -} - -impl<W: Write> Write for ZlibDecoder<W> { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - self.inner.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} - -impl<W: Read + Write> Read for ZlibDecoder<W> { - fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { - self.inner.get_mut().read(buf) - } -} |