Trait trackable::Trackable

pub trait Trackable {
    type Event: From<Location>;
    fn history(&self) -> Option<&History<Self::Event>>;
    fn history_mut(&mut self) -> Option<&mut History<Self::Event>>;

    fn track<F>(&mut self, f: F)
    where
        F: FnOnce() -> Self::Event,
    { ... }
    fn in_tracking(&self) -> bool { ... }
}

This trait allows to track an instance of an implementation type.

A trackable instance can have a tracking history that manages own backtrace-like (but more general) history for tracking.

You can add entries to the history by calling tracking macros(e.g., track!).

See TrackableError as a typical implementaion of this trait.

Examples

Defines a trackable type.

#[macro_use]
extern crate trackable;

use trackable::{Trackable, History, Location};

#[derive(Default)]
struct TrackableObject {
    history: History<Location>,
}
impl Trackable for TrackableObject {
    type Event = Location;
    fn history(&self) -> Option<&History<Self::Event>> {
        Some(&self.history)
    }
    fn history_mut(&mut self) -> Option<&mut History<Self::Event>> {
        Some(&mut self.history)
    }
}

fn main() {
    let o = TrackableObject::default();
    let o = track!(o);
    let o = track!(o, "Hello");
    let o = track!(o, "Hello {}", "World!");

    assert_eq!(format!("\n{}", o.history).replace('\\', "/"), r#"
HISTORY:
  [0] at src/lib.rs:23
  [1] at src/lib.rs:24 -- Hello
  [2] at src/lib.rs:25 -- Hello World!
"#);
}

Associated Types

type Event: From<Location>

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

Required Methods

fn history(&self) -> Option<&History<Self::Event>>

Returns the reference of the tracking history of this instance.

If it is not being tracked, this will return `None.

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

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

If it is not being tracked, this will return `None.

Provided Methods

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

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

Typically, this is called via track! macro.

fn in_tracking(&self) -> bool

Returns true if it is being tracked, otherwise false.

Implementations on Foreign Types

impl<T: Trackable> Trackable for Option<T>

type Event = T::Event

fn history(&self) -> Option<&History<Self::Event>>

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

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

fn in_tracking(&self) -> bool

impl<T, E: Trackable> Trackable for Result<T, E>

type Event = E::Event

fn history(&self) -> Option<&History<Self::Event>>

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

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

fn in_tracking(&self) -> bool

Implementors

• impl Trackable for Failure type Event = Location;
• impl Trackable for IoError type Event = Location;
• impl<K> Trackable for TrackableError<K> type Event = Location;