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, IntoTrackableError, ErrorKind, ErrorKindExt};

type MyError = TrackableError<MyErrorKind>;

#[derive(Debug, PartialEq, Eq)]
enum MyErrorKind {
    Critical,
    NonCritical,
}
impl ErrorKind for MyErrorKind {
    fn is_tracking_needed(&self) -> bool {
        *self == MyErrorKind::Critical  // Only critical errors are tracked
    }
}
impl IntoTrackableError<std::io::Error> for MyErrorKind {
    fn into_trackable_error(e: std::io::Error) -> MyError {
        // Any I/O errors are considered critical
        MyErrorKind::Critical.cause(e)
    }
}

fn main() {
    // Tracks an error
    let error: MyError = MyErrorKind::Critical.cause("something wrong");
    let error = track!(error);
    let error = track!(error, "I passed here");
    assert_eq!(format!("\nError: {}", error), r#"
Error: Critical (cause; something wrong)
HISTORY:
  [0] at rust_out:<anon>:28
  [1] at rust_out:<anon>:29; I passed here
"#);

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

Methods

impl<K: ErrorKind> TrackableError<K>

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

Makes a new TrackableError instance.

fn from_cause<E>(cause: E) -> Self where K: IntoTrackableError<E>

Makes a new TrackableError instance from cause.

fn kind(&self) -> &K

Returns the kind of this error.

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<K: Debug> Debug for TrackableError<K>

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

Formats the value using the given formatter.

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 assign_tracking_number(&mut self)

Assigns a randomly generated tracking number to this instance.

fn tracking_number(&self) -> Option<TrackingNumber>

Returns the tracking number of this instance if it has been assigned.

fn enable_tracking(self) -> Self where Self: Sized

Enables tracking of this instance.

fn disable_tracking(self) -> Self where Self: Sized

Disables tracking of this intance.

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 tracking of this instance is enabled, otherwise false.