Merge pull request #461 from CosminPerRam/experimental/traits

feat: add Error associated type in zio::Ops to handle multiple errors

Author: Byron

src/zio.rs

@@ -2,7 +2,9 @@ use std::io;
 use std::io::prelude::*;
 use std::mem;
 
-use crate::{Compress, Decompress, DecompressError, FlushCompress, FlushDecompress, Status};
+use crate::{
+    Compress, CompressError, Decompress, DecompressError, FlushCompress, FlushDecompress, Status,
+};
 
 #[derive(Debug)]
 pub struct Writer<W: Write, D: Ops> {
@@ -12,6 +14,7 @@ pub struct Writer<W: Write, D: Ops> {
 }
 
 pub trait Ops {
+    type Error: Into<io::Error>;
     type Flush: Flush;
     fn total_in(&self) -> u64;
     fn total_out(&self) -> u64;
@@ -20,16 +23,17 @@ pub trait Ops {
         input: &[u8],
         output: &mut [u8],
         flush: Self::Flush,
-    ) -> Result<Status, DecompressError>;
+    ) -> Result<Status, Self::Error>;
     fn run_vec(
         &mut self,
         input: &[u8],
         output: &mut Vec<u8>,
         flush: Self::Flush,
-    ) -> Result<Status, DecompressError>;
+    ) -> Result<Status, Self::Error>;
 }
 
 impl Ops for Compress {
+    type Error = CompressError;
     type Flush = FlushCompress;
     fn total_in(&self) -> u64 {
         self.total_in()
@@ -42,20 +46,21 @@ impl Ops for Compress {
         input: &[u8],
         output: &mut [u8],
         flush: FlushCompress,
-    ) -> Result<Status, DecompressError> {
-        Ok(self.compress(input, output, flush).unwrap())
+    ) -> Result<Status, CompressError> {
+        self.compress(input, output, flush)
     }
     fn run_vec(
         &mut self,
         input: &[u8],
         output: &mut Vec<u8>,
         flush: FlushCompress,
-    ) -> Result<Status, DecompressError> {
-        Ok(self.compress_vec(input, output, flush).unwrap())
+    ) -> Result<Status, CompressError> {
+        self.compress_vec(input, output, flush)
     }
 }
 
 impl Ops for Decompress {
+    type Error = DecompressError;
     type Flush = FlushDecompress;
     fn total_in(&self) -> u64 {
         self.total_in()
@@ -170,7 +175,9 @@ impl<W: Write, D: Ops> Writer<W, D> {
             self.dump()?;
 
             let before = self.data.total_out();
-            self.data.run_vec(&[], &mut self.buf, D::Flush::finish())?;
+            self.data
+                .run_vec(&[], &mut self.buf, Flush::finish())
+                .map_err(Into::into)?;
             if before == self.data.total_out() {
                 return Ok(());
             }
@@ -254,8 +261,8 @@ impl<W: Write, D: Ops> Write for Writer<W, D> {
 
     fn flush(&mut self) -> io::Result<()> {
         self.data
-            .run_vec(&[], &mut self.buf, D::Flush::sync())
-            .unwrap();
+            .run_vec(&[], &mut self.buf, Flush::sync())
+            .map_err(Into::into)?;
 
         // Unfortunately miniz doesn't actually tell us when we're done with
         // pulling out all the data from the internal stream. To remedy this we
@@ -266,8 +273,8 @@ impl<W: Write, D: Ops> Write for Writer<W, D> {
             self.dump()?;
             let before = self.data.total_out();
             self.data
-                .run_vec(&[], &mut self.buf, D::Flush::none())
-                .unwrap();
+                .run_vec(&[], &mut self.buf, Flush::none())
+                .map_err(Into::into)?;
             if before == self.data.total_out() {
                 break;
             }