Struct TrackableError

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

Trackable error.

Examples

Defines your own Error type.

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

#[derive(Debug, TrackableError)]
#[trackable(error_kind = "MyErrorKind")]
struct MyError(TrackableError<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`!
"#);
}

Implementations

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K> Deserialize<'de> for TrackableError<K>

where K: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

👎Deprecated since 1.42.0: use the Display impl or to_string()

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

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Failure> for TrackableError<Failed>

fn from(f: Failure) -> Self

Converts to this type from the input type.

impl From<IoError> for TrackableError<ErrorKind>

fn from(f: IoError) -> Self

Converts to this type from the input type.

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

fn from(kind: K) -> Self

Converts to this type from the input type.

impl From<TrackableError<ErrorKind>> for IoError

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

Converts to this type from the input type.

impl From<TrackableError<Failed>> for Failure

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

Converts to this type from the input type.

impl<K> Serialize for TrackableError<K>

where K: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K> Trackable for TrackableError<K>

type Event = Location

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.