Struct trackable::error::TrackableError

pub struct TrackableError<K> { /* fields omitted */ }

Trackable error.

Examples

Defines your own Error type.

#[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);
}

TrackableError is cloneable if K is so.

#[macro_use]
extern crate trackable;

use trackable::Trackable;
use trackable::error::{Failed, ErrorKindExt};

fn main() {
    let mut original = Failed.error();

    let original = track!(original, "Hello `original`!");
    let forked = original.clone();
    let forked = track!(forked, "Hello `forked`!");

    assert_eq!(format!("\n{}", original).replace('\\', "/"), r#"
Failed
HISTORY:
  [0] at src/error.rs:11 -- Hello `original`!
"#);

    assert_eq!(format!("\n{}", forked).replace('\\', "/"), r#"
Failed
HISTORY:
  [0] at src/error.rs:11 -- Hello `original`!
  [1] at src/error.rs:13 -- Hello `forked`!
"#);
}

Methods

impl<K: ErrorKind> TrackableError<K>

pub fn new<E>(kind: K, cause: E) -> Self where
    E: Into<BoxError>, 

Makes a new TrackableError instance.

pub fn kind(&self) -> &K

Returns the kind of this error.

pub fn concrete_cause<T>(&self) -> Option<&T> where
    T: Error + 'static, 

Tries to return the cause of this error as a value of T type.

If neither this error has a cause nor it is an T value, this method will return None.

Trait Implementations

impl From<TrackableError<Failed>> for Failure

fn from(f: TrackableError<Failed>) -> Self

Performs the conversion.

impl From<Failure> for TrackableError<Failed>

fn from(f: Failure) -> Self

Performs the conversion.

impl<K: Debug> Debug for TrackableError<K>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<K: Clone> Clone for TrackableError<K>

fn clone(&self) -> TrackableError<K>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: ErrorKind> From<K> for TrackableError<K>

fn from(kind: K) -> Self

Performs the conversion.

impl<K: ErrorKind + Default> Default for TrackableError<K>

fn default() -> Self

Returns the "default value" for a type.

impl<K: ErrorKind> Display for TrackableError<K>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<K: ErrorKind> Error for TrackableError<K>

fn description(&self) -> &str

A short description of the error.

fn cause(&self) -> Option<&Error>

The lower-level cause of this error, if any.

impl<K> Trackable for TrackableError<K>

type Event = Event

Event type which a history of an instance of this type can have.

fn history(&self) -> Option<&History>

Returns the reference of the tracking history of this instance.

fn history_mut(&mut self) -> Option<&mut History>

Returns the mutable reference of the tracking history of this instance.

fn track<F>(&mut self, f: F) where
    F: FnOnce() -> Self::Event, 

Add an event into the tail of the history of this instance.

fn in_tracking(&self) -> bool

Returns true if it is being tracked, otherwise false.