Module trackable::error

Functionalities for implementing trackable errors and operating on those.

You can easily define your own trackable error types as follows:

#[macro_use]
extern crate trackable;
use trackable::error::{TrackableError, ErrorKind, ErrorKindExt};

#[derive(Debug)]
struct MyError(TrackableError<MyErrorKind>);
derive_traits_for_trackable_error_newtype!(MyError, MyErrorKind);
impl From<std::io::Error> for MyError {
    fn from(f: std::io::Error) -> Self {
        // Any I/O errors are considered critical
        MyErrorKind::Critical.cause(f).into()
    }
}

#[derive(Debug, PartialEq, Eq)]
enum MyErrorKind {
    Critical,
    NonCritical,
}
impl ErrorKind for MyErrorKind {}

fn main() {
    // Tracks an error
    let error: MyError = MyErrorKind::Critical.cause("something wrong").into();
    let error = track!(error);
    let error = track!(error, "I passed here");
    assert_eq!(format!("\nError: {}", error).replace('\\', "/"), r#"
Error: Critical (cause; something wrong)
HISTORY:
  [0] at src/error.rs:27
  [1] at src/error.rs:28 -- I passed here
"#);

    // Tries to execute I/O operation
    let result = (|| -> Result<_, MyError> {
        let f = track!(std::fs::File::open("/path/to/non_existent_file")
                       .map_err(MyError::from))?;
        Ok(f)
    })();
    let error = result.err().unwrap();
    let cause = error.concrete_cause::<std::io::Error>().unwrap();
    assert_eq!(cause.kind(), std::io::ErrorKind::NotFound);
}

Structs

Failed	Built-in ErrorKind implementation which represents opaque errors.
Failure	TrackableError type specialized for Failed.
IoError	A variant of std::io::Error that implements Trackable trait.
TrackableError	Trackable error.

Traits

ErrorKind	This trait represents a error kind which TrackableError can have.
ErrorKindExt	An extention of ErrorKind trait.

Type Definitions

BoxError	Boxed Error object.
BoxErrorKind	Boxed ErrorKind object.
History	History type specialized for TrackableError.