error types generalized.

Author: dapper91

README.md

@@ -41,7 +41,7 @@ For more information see https://en.wikipedia.org/wiki/External_sorting.
         let input_reader = io::BufReader::new(fs::File::open("input.txt").unwrap());
         let mut output_writer = io::BufWriter::new(fs::File::create("output.txt").unwrap());
 
-        let sorter: ExternalSorter<String, MemoryLimitedBufferBuilder> = ExternalSorterBuilder::new()
+        let sorter: ExternalSorter<String, io::Error, MemoryLimitedBufferBuilder> = ExternalSorterBuilder::new()
             .with_tmp_dir(path::Path::new("tmp"))
             .with_buffer(MemoryLimitedBufferBuilder::new(50 * MB))
             .build()

examples/quickstart.rs

@@ -15,7 +15,7 @@ fn main() {
     let input_reader = io::BufReader::new(fs::File::open("input.txt").unwrap());
     let mut output_writer = io::BufWriter::new(fs::File::create("output.txt").unwrap());
 
-    let sorter: ExternalSorter<String, MemoryLimitedBufferBuilder> = ExternalSorterBuilder::new()
+    let sorter: ExternalSorter<String, io::Error, MemoryLimitedBufferBuilder> = ExternalSorterBuilder::new()
         .with_tmp_dir(path::Path::new("tmp"))
         .with_buffer(MemoryLimitedBufferBuilder::new(50 * MB))
         .build()

src/chunk.rs

@@ -1,27 +1,54 @@
 use std::error::Error;
+use std::fmt::{self, Display};
 use std::fs;
 use std::io;
 use std::io::prelude::*;
 use std::marker::PhantomData;
 
 use tempfile;
 
+/// External chunk error
+#[derive(Debug)]
+pub enum ExternalChunkError<S: Error> {
+    /// Common I/O error.
+    IO(io::Error),
+    /// Data serialization error.
+    SerializationError(S),
+}
+
+impl<S: Error> Error for ExternalChunkError<S> {}
+
+impl<S: Error> Display for ExternalChunkError<S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl<S: Error> From<io::Error> for ExternalChunkError<S> {
+    fn from(err: io::Error) -> Self {
+        ExternalChunkError::IO(err)
+    }
+}
+
 /// External chunk interface. Provides methods for creating a chunk stored on file system and reading data from it.
-pub trait ExternalChunk<T>: Sized + Iterator<Item = Result<T, Box<dyn Error>>> {
+pub trait ExternalChunk<T>: Sized + Iterator<Item = Result<T, Self::DeserializationError>> {
+    type SerializationError: Error;
+    type DeserializationError: Error;
+
     /// Builds an instance of an external chunk.
     fn build(
         dir: &tempfile::TempDir,
         items: impl IntoIterator<Item = T>,
         buf_size: Option<usize>,
-    ) -> Result<Self, Box<dyn Error>> {
+    ) -> Result<Self, ExternalChunkError<Self::SerializationError>> {
         let tmp_file = tempfile::tempfile_in(dir)?;
 
         let mut chunk_writer = match buf_size {
             Some(buf_size) => io::BufWriter::with_capacity(buf_size, tmp_file.try_clone()?),
             None => io::BufWriter::new(tmp_file.try_clone()?),
         };
 
-        Self::dump(&mut chunk_writer, items)?;
+        Self::dump(&mut chunk_writer, items).map_err(ExternalChunkError::SerializationError)?;
 
         chunk_writer.flush()?;
 
@@ -43,7 +70,7 @@ pub trait ExternalChunk<T>: Sized + Iterator<Item = Result<T, Box<dyn Error>>> {
     fn dump(
         chunk_writer: &mut io::BufWriter<fs::File>,
         items: impl IntoIterator<Item = T>,
-    ) -> Result<(), Box<dyn Error>>;
+    ) -> Result<(), Self::SerializationError>;
 }
 
 /// RMP (Rust MessagePack) external chunk implementation.
@@ -59,6 +86,9 @@ impl<T> ExternalChunk<T> for RmpExternalChunk<T>
 where
     T: serde::ser::Serialize + serde::de::DeserializeOwned,
 {
+    type SerializationError = rmp_serde::encode::Error;
+    type DeserializationError = rmp_serde::decode::Error;
+
     fn new(reader: io::Take<io::BufReader<fs::File>>) -> Self {
         RmpExternalChunk {
             reader,
@@ -69,7 +99,7 @@ where
     fn dump(
         mut chunk_writer: &mut io::BufWriter<fs::File>,
         items: impl IntoIterator<Item = T>,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<(), Self::SerializationError> {
         for item in items.into_iter() {
             rmp_serde::encode::write(&mut chunk_writer, &item)?;
         }
@@ -82,24 +112,22 @@ impl<T> Iterator for RmpExternalChunk<T>
 where
     T: serde::ser::Serialize + serde::de::DeserializeOwned,
 {
-    type Item = Result<T, Box<dyn Error>>;
+    type Item = Result<T, <Self as ExternalChunk<T>>::DeserializationError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.reader.limit() == 0 {
             None
         } else {
             match rmp_serde::decode::from_read(&mut self.reader) {
                 Ok(result) => Some(Ok(result)),
-                Err(err) => Some(Err(Box::new(err))),
+                Err(err) => Some(Err(err)),
             }
         }
     }
 }
 
 #[cfg(test)]
 mod test {
-    use std::error::Error;
-
     use rstest::*;
 
     use super::{ExternalChunk, RmpExternalChunk};
@@ -113,9 +141,9 @@ mod test {
     fn test_rmp_chunk(tmp_dir: tempfile::TempDir) {
         let saved = Vec::from_iter(0..100);
 
-        let chunk: RmpExternalChunk<_> = ExternalChunk::build(&tmp_dir, saved.clone(), None).unwrap();
+        let chunk: RmpExternalChunk<i32> = ExternalChunk::build(&tmp_dir, saved.clone(), None).unwrap();
 
-        let restored: Result<Vec<i32>, Box<dyn Error>> = chunk.collect();
+        let restored: Result<Vec<i32>, _> = chunk.collect();
         let restored = restored.unwrap();
 
         assert_eq!(restored, saved);

src/merger.rs

@@ -7,21 +7,23 @@ use std::error::Error;
 /// Merges multiple sorted inputs into a single sorted output.
 /// Time complexity is *m* \* log(*n*) in worst case where *m* is the number of items,
 /// *n* is the number of chunks (inputs).
-pub struct BinaryHeapMerger<T, C>
+pub struct BinaryHeapMerger<T, E, C>
 where
     T: Ord,
-    C: IntoIterator<Item = Result<T, Box<dyn Error>>>,
+    E: Error,
+    C: IntoIterator<Item = Result<T, E>>,
 {
     // binary heap is max-heap by default so we reverse it to convert it to min-heap
     items: BinaryHeap<(std::cmp::Reverse<T>, usize)>,
     chunks: Vec<C::IntoIter>,
     initiated: bool,
 }
 
-impl<T, C> BinaryHeapMerger<T, C>
+impl<T, E, C> BinaryHeapMerger<T, E, C>
 where
     T: Ord,
-    C: IntoIterator<Item = Result<T, Box<dyn Error>>>,
+    E: Error,
+    C: IntoIterator<Item = Result<T, E>>,
 {
     /// Creates an instance of binary heap merger using chunks as inputs.
     /// Chunk items should be sorted in ascending order otherwise the result is undefined.
@@ -40,12 +42,13 @@ where
     }
 }
 
-impl<T, C> Iterator for BinaryHeapMerger<T, C>
+impl<T, E, C> Iterator for BinaryHeapMerger<T, E, C>
 where
     T: Ord,
-    C: IntoIterator<Item = Result<T, Box<dyn Error>>>,
+    E: Error,
+    C: IntoIterator<Item = Result<T, E>>,
 {
-    type Item = Result<T, Box<dyn Error>>;
+    type Item = Result<T, E>;
 
     /// Returns the next item from inputs in ascending order.
     fn next(&mut self) -> Option<Self::Item> {
@@ -104,26 +107,26 @@ mod test {
     )]
     #[case(
         vec![
-            vec![Result::<i32, Box<dyn Error>>::Err(Box::new(io::Error::new(ErrorKind::Other, "test error")))]
+            vec![Result::Err(io::Error::new(ErrorKind::Other, "test error"))]
         ],
         vec![
-            Result::<i32, Box<dyn Error>>::Err(Box::new(io::Error::new(ErrorKind::Other, "test error")))
+            Result::Err(io::Error::new(ErrorKind::Other, "test error"))
         ],
     )]
     #[case(
         vec![
-            vec![Ok(3), Result::<i32, Box<dyn Error>>::Err(Box::new(io::Error::new(ErrorKind::Other, "test error")))],
+            vec![Ok(3), Result::Err(io::Error::new(ErrorKind::Other, "test error"))],
             vec![Ok(1), Ok(2)],
         ],
         vec![
             Ok(1),
             Ok(2),
-            Result::<i32, Box<dyn Error>>::Err(Box::new(io::Error::new(ErrorKind::Other, "test error"))),
+            Result::Err(io::Error::new(ErrorKind::Other, "test error")),
         ],
     )]
     fn test_merger(
-        #[case] chunks: Vec<Vec<Result<i32, Box<dyn Error>>>>,
-        #[case] expected_result: Vec<Result<i32, Box<dyn Error>>>,
+        #[case] chunks: Vec<Vec<Result<i32, io::Error>>>,
+        #[case] expected_result: Vec<Result<i32, io::Error>>,
     ) {
         let merger = BinaryHeapMerger::new(chunks);
         let actual_result = merger.collect();
@@ -136,16 +139,16 @@ mod test {
     }
 
     fn compare_vectors_of_result<T: PartialEq, E: Error + 'static>(
-        actual: &Vec<Result<T, Box<dyn Error>>>,
-        expected: &Vec<Result<T, Box<dyn Error>>>,
+        actual: &Vec<Result<T, E>>,
+        expected: &Vec<Result<T, E>>,
     ) -> bool {
         actual
             .into_iter()
             .zip(expected)
             .all(
                 |(actual_result, expected_result)| match (actual_result, expected_result) {
                     (Ok(actual_result), Ok(expected_result)) if actual_result == expected_result => true,
-                    (Err(actual_err), Err(expected_err)) if actual_err.is::<E>() && expected_err.is::<E>() => true,
+                    (Err(actual_err), Err(expected_err)) => actual_err.to_string() == expected_err.to_string(),
                     _ => false,
                 },
             )