Add structs and traits for supporting implicit finishing when drops

src/deflate/encode.rs

@@ -5,7 +5,7 @@ use byteorder::WriteBytesExt;
 
 use bit;
 use lz77;
-use finish::Finish;
+use finish::{Complete, Finish};
 use super::symbol;
 use super::BlockType;
 
@@ -237,6 +237,15 @@ where
         self.writer.as_inner_mut().flush()
     }
 }
+impl<W, E> Complete for Encoder<W, E>
+where
+    W: io::Write,
+    E: lz77::Lz77Encode,
+{
+    fn complete(self) -> io::Result<()> {
+        self.finish().into_result().map(|_| ())
+    }
+}
 
 #[derive(Debug)]
 struct Block<E> {

src/finish.rs

@@ -1,3 +1,7 @@
+//! `Finish` and related types.
+use std::io::{self, Write};
+use std::ops::{Deref, DerefMut};
+
 /// `Finish` is a type that represents a value which
 /// may have an error occurred during the computation.
 ///
@@ -85,3 +89,133 @@ impl<T, E> Finish<T, E> {
         }
     }
 }
+
+/// A wrapper struct that completes the processing of the underlying instance when drops.
+///
+/// This calls `Complete:::complete` method of `T` when drops.
+///
+/// # Panics
+///
+/// If the invocation of `Complete::complete(T)` returns an error, `AutoFinish::drop()` will panic.
+#[derive(Debug)]
+pub struct AutoFinish<T: Complete> {
+    inner: Option<T>,
+}
+impl<T: Complete> AutoFinish<T> {
+    /// Makes a new `AutoFinish` instance.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io;
+    /// use libflate::finish::AutoFinish;
+    /// use libflate::gzip::Encoder;
+    ///
+    /// let plain = b"Hello World!";
+    /// let mut buf = Vec::new();
+    /// let mut encoder = AutoFinish::new(Encoder::new(&mut buf).unwrap());
+    /// io::copy(&mut &plain[..], &mut encoder).unwrap();
+    /// ```
+    pub fn new(inner: T) -> Self {
+        AutoFinish { inner: Some(inner) }
+    }
+
+    /// Unwraps this `AutoFinish` instance, returning the underlying instance.
+    pub fn into_inner(mut self) -> T {
+        self.inner.take().expect("Never fails")
+    }
+}
+impl<T: Complete> Drop for AutoFinish<T> {
+    fn drop(&mut self) {
+        if let Some(inner) = self.inner.take() {
+            if let Err(e) = inner.complete() {
+                panic!("{}", e);
+            }
+        }
+    }
+}
+impl<T: Complete> Deref for AutoFinish<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        self.inner.as_ref().expect("Never fails")
+    }
+}
+impl<T: Complete> DerefMut for AutoFinish<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.as_mut().expect("Never fails")
+    }
+}
+impl<T: Complete + Write> Write for AutoFinish<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.deref_mut().write(buf)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.deref_mut().flush()
+    }
+}
+
+/// A wrapper struct that completes the processing of the underlying instance when drops.
+///
+/// This calls `Complete:::complete` method of `T` when drops.
+///
+/// Note that this ignores the result of the invocation of `Complete::complete(T)`.
+#[derive(Debug)]
+pub struct AutoFinishUnchecked<T: Complete> {
+    inner: Option<T>,
+}
+impl<T: Complete> AutoFinishUnchecked<T> {
+    /// Makes a new `AutoFinishUnchecked` instance.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io;
+    /// use libflate::finish::AutoFinishUnchecked;
+    /// use libflate::gzip::Encoder;
+    ///
+    /// let plain = b"Hello World!";
+    /// let mut buf = Vec::new();
+    /// let mut encoder = AutoFinishUnchecked::new(Encoder::new(&mut buf).unwrap());
+    /// io::copy(&mut &plain[..], &mut encoder).unwrap();
+    /// ```
+    pub fn new(inner: T) -> Self {
+        AutoFinishUnchecked { inner: Some(inner) }
+    }
+
+    /// Unwraps this `AutoFinishUnchecked` instance, returning the underlying instance.
+    pub fn into_inner(mut self) -> T {
+        self.inner.take().expect("Never fails")
+    }
+}
+impl<T: Complete> Drop for AutoFinishUnchecked<T> {
+    fn drop(&mut self) {
+        if let Some(inner) = self.inner.take() {
+            let _ = inner.complete();
+        }
+    }
+}
+impl<T: Complete> Deref for AutoFinishUnchecked<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        self.inner.as_ref().expect("Never fails")
+    }
+}
+impl<T: Complete> DerefMut for AutoFinishUnchecked<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.as_mut().expect("Never fails")
+    }
+}
+impl<T: Complete + Write> Write for AutoFinishUnchecked<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.deref_mut().write(buf)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.deref_mut().flush()
+    }
+}
+
+/// This trait allows to complete an I/O related processing.
+pub trait Complete {
+    /// Completes the current processing and returns the result.
+    fn complete(self) -> io::Result<()>;
+}

src/gzip.rs

@@ -29,7 +29,7 @@ use byteorder::LittleEndian;
 use lz77;
 use deflate;
 use checksum;
-use finish::Finish;
+use finish::{Complete, Finish};
 
 const GZIP_ID: [u8; 2] = [31, 139];
 const COMPRESSION_METHOD_DEFLATE: u8 = 8;
@@ -779,6 +779,22 @@ where
     ///
     /// assert!(encoder.finish().as_result().is_ok())
     /// ```
+    ///
+    /// # Note
+    ///
+    /// If you are not concerned the result of this encoding,
+    /// it may be convenient to use `AutoFinishUnchecked` instead of the explicit invocation of this method.
+    ///
+    /// ```
+    /// use std::io;
+    /// use libflate::finish::AutoFinishUnchecked;
+    /// use libflate::gzip::Encoder;
+    ///
+    /// let plain = b"Hello World!";
+    /// let mut buf = Vec::new();
+    /// let mut encoder = AutoFinishUnchecked::new(Encoder::new(&mut buf).unwrap());
+    /// io::copy(&mut &plain[..], &mut encoder).unwrap();
+    /// ```
     pub fn finish(self) -> Finish<W, io::Error> {
         let trailer = Trailer {
             crc32: self.crc32.value(),
@@ -806,6 +822,15 @@ where
         self.writer.flush()
     }
 }
+impl<W, E> Complete for Encoder<W, E>
+where
+    W: io::Write,
+    E: lz77::Lz77Encode,
+{
+    fn complete(self) -> io::Result<()> {
+        self.finish().into_result().map(|_| ())
+    }
+}
 
 /// GZIP decoder.
 #[derive(Debug)]
@@ -915,6 +940,7 @@ where
 #[cfg(test)]
 mod test {
     use std::io;
+    use finish::AutoFinish;
     use super::*;
 
     fn decode_all(buf: &[u8]) -> io::Result<Vec<u8>> {
@@ -932,4 +958,15 @@ mod test {
         let encoded = encoder.finish().into_result().unwrap();
         assert_eq!(decode_all(&encoded).unwrap(), plain);
     }
+
+    #[test]
+    fn encoder_auto_finish_works() {
+        let plain = b"Hello World! Hello GZIP!!";
+        let mut buf = Vec::new();
+        {
+            let mut encoder = AutoFinish::new(Encoder::new(&mut buf).unwrap());
+            io::copy(&mut &plain[..], &mut encoder).unwrap();
+        }
+        assert_eq!(decode_all(&buf).unwrap(), plain);
+    }
 }

src/lib.rs

@@ -28,9 +28,9 @@ pub mod zlib;
 pub mod gzip;
 pub mod deflate;
 pub mod non_blocking;
+pub mod finish;
 
 mod bit;
-mod finish;
 mod huffman;
 mod checksum;
 mod util;

src/zlib.rs

@@ -27,7 +27,7 @@ use byteorder::WriteBytesExt;
 use lz77;
 use deflate;
 use checksum;
-use finish::Finish;
+use finish::{Complete, Finish};
 
 const COMPRESSION_METHOD_DEFLATE: u8 = 8;
 
@@ -550,6 +550,22 @@ where
     ///            [120, 156, 5, 128, 65, 9, 0, 0, 8, 3, 171, 104, 27, 27, 88, 64, 127,
     ///             7, 131, 245, 127, 140, 121, 80, 173, 204, 117, 0, 28, 73, 4, 62]);
     /// ```
+    ///
+    /// # Note
+    ///
+    /// If you are not concerned the result of this encoding,
+    /// it may be convenient to use `AutoFinishUnchecked` instead of the explicit invocation of this method.
+    ///
+    /// ```
+    /// use std::io;
+    /// use libflate::finish::AutoFinishUnchecked;
+    /// use libflate::zlib::Encoder;
+    ///
+    /// let plain = b"Hello World!";
+    /// let mut buf = Vec::new();
+    /// let mut encoder = AutoFinishUnchecked::new(Encoder::new(&mut buf).unwrap());
+    /// io::copy(&mut &plain[..], &mut encoder).unwrap();
+    /// ```
     pub fn finish(self) -> Finish<W, io::Error> {
         let mut inner = finish_try!(self.writer.finish());
         match inner
@@ -575,10 +591,20 @@ where
         self.writer.flush()
     }
 }
+impl<W, E> Complete for Encoder<W, E>
+where
+    W: io::Write,
+    E: lz77::Lz77Encode,
+{
+    fn complete(self) -> io::Result<()> {
+        self.finish().into_result().map(|_| ())
+    }
+}
 
 #[cfg(test)]
 mod test {
     use std::io;
+    use finish::AutoFinish;
     use super::*;
 
     fn decode_all(buf: &[u8]) -> io::Result<Vec<u8>> {
@@ -659,6 +685,17 @@ mod test {
         assert_eq!(decode_all(&encoded).unwrap(), plain);
     }
 
+    #[test]
+    fn encoder_auto_finish_works() {
+        let plain = b"Hello World! Hello ZLIB!!";
+        let mut buf = Vec::new();
+        {
+            let mut encoder = AutoFinish::new(Encoder::new(&mut buf).unwrap());
+            io::copy(&mut &plain[..], &mut encoder).unwrap();
+        }
+        assert_eq!(decode_all(&buf).unwrap(), plain);
+    }
+
     #[test]
     fn test_issue_2() {
         // See: https://github.com/sile/libflate/issues/2