Use failure

Author: ordovicia

Cargo.toml

@@ -14,6 +14,7 @@ rand = "0.3.9"
 
 [dependencies]
 num-traits = "0.2"
+failure = "0.1.3"
 
 [dependencies.serde]
 version = "1.0"

src/error.rs

@@ -0,0 +1,57 @@
+use failure::{Backtrace, Context, Fail};
+use std::fmt::{self, Display};
+
+#[derive(Debug)]
+pub struct Error {
+    inner: Context<ErrorKind>,
+}
+
+#[derive(Debug, PartialEq, Fail)]
+pub enum ErrorKind {
+    #[fail(display = "wrong dimension")]
+    WrongDimension,
+    #[fail(display = "non-finite coordinate")]
+    NonFiniteCoordinate,
+    #[fail(display = "zero capacity")]
+    ZeroCapacity,
+}
+
+impl Fail for Error {
+    fn cause(&self) -> Option<&Fail> {
+        self.inner.cause()
+    }
+
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.inner.backtrace()
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+impl Error {
+    pub fn new(inner: Context<ErrorKind>) -> Error {
+        Error { inner }
+    }
+
+    pub fn kind(&self) -> &ErrorKind {
+        self.inner.get_context()
+    }
+}
+
+impl From<ErrorKind> for Error {
+    fn from(kind: ErrorKind) -> Error {
+        Error {
+            inner: Context::new(kind),
+        }
+    }
+}
+
+impl From<Context<ErrorKind>> for Error {
+    fn from(inner: Context<ErrorKind>) -> Error {
+        Error { inner }
+    }
+}

src/kdtree.rs

@@ -2,6 +2,7 @@ use std::collections::BinaryHeap;
 
 use num_traits::{Float, One, Zero};
 
+use crate::error::{Error, ErrorKind};
 use crate::heap_element::HeapElement;
 use crate::util;
 
@@ -25,14 +26,7 @@ pub struct KdTree<A, T, U: AsRef<[A]>> {
     bucket: Option<Vec<T>>,
 }
 
-#[derive(Debug, PartialEq)]
-pub enum ErrorKind {
-    WrongDimension,
-    NonFiniteCoordinate,
-    ZeroCapacity,
-}
-
-impl<A: Float + Zero + One, T, U: AsRef<[A]>> KdTree<A, T, U> {
+impl<A: Float + Zero + One + Zero + One, T, U: AsRef<[A]>> KdTree<A, T, U> {
     pub fn new(dims: usize) -> Self {
         KdTree::new_with_capacity(dims, 2usize.pow(4))
     }
@@ -59,12 +53,7 @@ impl<A: Float + Zero + One, T, U: AsRef<[A]>> KdTree<A, T, U> {
         self.size
     }
 
-    pub fn nearest<F>(
-        &self,
-        point: &[A],
-        num: usize,
-        distance: &F,
-    ) -> Result<Vec<(A, &T)>, ErrorKind>
+    pub fn nearest<F>(&self, point: &[A], num: usize, distance: &F) -> Result<Vec<(A, &T)>, Error>
     where
         F: Fn(&[A], &[A]) -> A,
     {
@@ -102,7 +91,7 @@ impl<A: Float + Zero + One, T, U: AsRef<[A]>> KdTree<A, T, U> {
             .collect())
     }
 
-    pub fn within<F>(&self, point: &[A], ridius: A, distance: &F) -> Result<Vec<(A, &T)>, ErrorKind>
+    pub fn within<F>(&self, point: &[A], ridius: A, distance: &F) -> Result<Vec<(A, &T)>, Error>
     where
         F: Fn(&[A], &[A]) -> A,
     {
@@ -202,7 +191,7 @@ impl<A: Float + Zero + One, T, U: AsRef<[A]>> KdTree<A, T, U> {
         &'b self,
         point: &'a [A],
         distance: &'a F,
-    ) -> Result<NearestIter<'a, 'b, A, T, U, F>, ErrorKind>
+    ) -> Result<NearestIter<'a, 'b, A, T, U, F>, Error>
     where
         F: Fn(&[A], &[A]) -> A,
     {
@@ -223,17 +212,17 @@ impl<A: Float + Zero + One, T, U: AsRef<[A]>> KdTree<A, T, U> {
         })
     }
 
-    pub fn add(&mut self, point: U, data: T) -> Result<(), ErrorKind> {
+    pub fn add(&mut self, point: U, data: T) -> Result<(), Error> {
         if self.capacity == 0 {
-            return Err(ErrorKind::ZeroCapacity);
+            Err(ErrorKind::ZeroCapacity)?;
         }
         if let Err(err) = self.check_point(point.as_ref()) {
-            return Err(err);
+            Err(err)?;
         }
         self.add_unchecked(point, data)
     }
 
-    fn add_unchecked(&mut self, point: U, data: T) -> Result<(), ErrorKind> {
+    fn add_unchecked(&mut self, point: U, data: T) -> Result<(), Error> {
         if self.is_leaf() {
             self.add_to_bucket(point, data);
             return Ok(());
@@ -325,13 +314,13 @@ impl<A: Float + Zero + One, T, U: AsRef<[A]>> KdTree<A, T, U> {
             && self.right.is_none()
     }
 
-    fn check_point(&self, point: &[A]) -> Result<(), ErrorKind> {
+    fn check_point(&self, point: &[A]) -> Result<(), Error> {
         if self.dimensions != point.len() {
-            return Err(ErrorKind::WrongDimension);
+            Err(ErrorKind::WrongDimension)?;
         }
         for n in point {
             if !n.is_finite() {
-                return Err(ErrorKind::NonFiniteCoordinate);
+                Err(ErrorKind::NonFiniteCoordinate)?;
             }
         }
         Ok(())
@@ -399,23 +388,6 @@ where
     }
 }
 
-impl std::error::Error for ErrorKind {
-    fn description(&self) -> &str {
-        match *self {
-            ErrorKind::WrongDimension => "wrong dimension",
-            ErrorKind::NonFiniteCoordinate => "non-finite coordinate",
-            ErrorKind::ZeroCapacity => "zero capacity",
-        }
-    }
-}
-
-impl std::fmt::Display for ErrorKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        use std::error::Error;
-        write!(f, "KdTree error: {}", self.description())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     extern crate rand;

src/lib.rs

@@ -53,15 +53,18 @@
 //! );
 //! ```
 
+#[macro_use]
+extern crate failure;
 extern crate num_traits;
-
 #[cfg(feature = "serialize")]
 #[cfg_attr(feature = "serialize", macro_use)]
 extern crate serde_derive;
 
 pub mod distance;
+mod error;
 mod heap_element;
 pub mod kdtree;
 mod util;
-pub use crate::kdtree::ErrorKind;
+
+pub use crate::error::{Error, ErrorKind};
 pub use crate::kdtree::KdTree;

tests/kdtree.rs

@@ -114,13 +114,18 @@ fn it_works_with_vec() {
     );
 }
 
+macro_rules! assert_err_kind {
+    ($expr: expr, $err: expr) => {{
+        let err = $expr.unwrap_err();
+        assert_eq!(*err.kind(), $err);
+    }};
+}
+
 #[test]
 fn handles_zero_capacity() {
     let mut kdtree = KdTree::new_with_capacity(2, 0);
-    assert_eq!(
-        kdtree.add(&POINT_A.0, POINT_A.1),
-        Err(ErrorKind::ZeroCapacity)
-    );
+
+    assert_err_kind!(kdtree.add(&POINT_A.0, POINT_A.1), ErrorKind::ZeroCapacity);
     assert_eq!(
         kdtree.nearest(&POINT_A.0, 1, &squared_euclidean).unwrap(),
         vec![]
@@ -131,13 +136,11 @@ fn handles_zero_capacity() {
 fn handles_wrong_dimension() {
     let point = ([0f64], 0f64);
     let mut kdtree = KdTree::new_with_capacity(2, 1);
-    assert_eq!(
-        kdtree.add(&point.0, point.1),
-        Err(ErrorKind::WrongDimension)
-    );
-    assert_eq!(
+
+    assert_err_kind!(kdtree.add(&point.0, point.1), ErrorKind::WrongDimension);
+    assert_err_kind!(
         kdtree.nearest(&point.0, 1, &squared_euclidean),
-        Err(ErrorKind::WrongDimension)
+        ErrorKind::WrongDimension
     );
 }
 
@@ -146,21 +149,22 @@ fn handles_non_finite_coordinate() {
     let point_a = ([std::f64::NAN, std::f64::NAN], 0f64);
     let point_b = ([std::f64::INFINITY, std::f64::INFINITY], 0f64);
     let mut kdtree = KdTree::new_with_capacity(2, 1);
-    assert_eq!(
+
+    assert_err_kind!(
         kdtree.add(&point_a.0, point_a.1),
-        Err(ErrorKind::NonFiniteCoordinate)
+        ErrorKind::NonFiniteCoordinate
     );
-    assert_eq!(
+    assert_err_kind!(
         kdtree.add(&point_b.0, point_b.1),
-        Err(ErrorKind::NonFiniteCoordinate)
+        ErrorKind::NonFiniteCoordinate
     );
-    assert_eq!(
+    assert_err_kind!(
         kdtree.nearest(&point_a.0, 1, &squared_euclidean),
-        Err(ErrorKind::NonFiniteCoordinate)
+        ErrorKind::NonFiniteCoordinate
     );
-    assert_eq!(
+    assert_err_kind!(
         kdtree.nearest(&point_b.0, 1, &squared_euclidean),
-        Err(ErrorKind::NonFiniteCoordinate)
+        ErrorKind::NonFiniteCoordinate
     );
 }