Struct DataTracker

pub struct DataTracker<T, K>
where
    T: Clone + PartialEq,
    K: Hash + Eq,
{ /* private fields */ }

Tracks changes to data and notifies listeners.

The data to be tracked is type T.

Callbacks are stored in a HashMap with keys of type K.

See the module-level documentation for more details.

Implementations

impl<T, K> DataTracker<T, K>

where T: Clone + PartialEq, K: Hash + Eq,

pub fn new(value: T) -> DataTracker<T, K>

Create a new DataTracker which takes ownership of the data of type T.

Callbacks are registered via a key of type K.

Examples found in repository

examples/simple.rs (line 11)

fn main() {
    let mut data = DataTracker::new(MyData { a: 1 });
    let key = 0; // Keep the key to remove the callback later.
    data.add_listener(key,
                      Box::new(|old_value: &MyData, new_value: &MyData| {
                          println!("changed {:?} -> {:?}", old_value, new_value);
                      }));

    {
        // Create x, a (non-mutable) reference to original data.
        let x = data.as_ref();
        println!("x.a: {}", x.a);
    }

    {
        // Create x, which allows modifying the original data and checks for changes when
        // it goes out of scope.
        let mut x = data.as_tracked_mut();
        x.a = 10;
        println!("x.a: {}", x.a);
        // When we leave this scope, changes are detected and sent to the listeners.
    }

}

pub fn add_listener( &mut self, key: K, callback: Box<dyn OnChanged<T>>, ) -> Option<Box<dyn OnChanged<T>>>

Add a callback that will be called just after a data change is detected.

If a previous callback exists with the key, the original callback is returned as Some(original_callback). Otherwise, None is returned.

Examples found in repository

examples/simple.rs (lines 13-16)

fn main() {
    let mut data = DataTracker::new(MyData { a: 1 });
    let key = 0; // Keep the key to remove the callback later.
    data.add_listener(key,
                      Box::new(|old_value: &MyData, new_value: &MyData| {
                          println!("changed {:?} -> {:?}", old_value, new_value);
                      }));

    {
        // Create x, a (non-mutable) reference to original data.
        let x = data.as_ref();
        println!("x.a: {}", x.a);
    }

    {
        // Create x, which allows modifying the original data and checks for changes when
        // it goes out of scope.
        let mut x = data.as_tracked_mut();
        x.a = 10;
        println!("x.a: {}", x.a);
        // When we leave this scope, changes are detected and sent to the listeners.
    }

}

pub fn remove_listener(&mut self, key: &K) -> Option<Box<dyn OnChanged<T>>>

Remove callback.

If a callback exists with the key, it is removed and returned as Some(callback). Otherwise, None is returned.

pub fn as_tracked_mut(&mut self) -> Modifier<'_, T, K>

Return a Modifier which can be used to modify the owned data.

Examples found in repository

examples/simple.rs (line 27)

fn main() {
    let mut data = DataTracker::new(MyData { a: 1 });
    let key = 0; // Keep the key to remove the callback later.
    data.add_listener(key,
                      Box::new(|old_value: &MyData, new_value: &MyData| {
                          println!("changed {:?} -> {:?}", old_value, new_value);
                      }));

    {
        // Create x, a (non-mutable) reference to original data.
        let x = data.as_ref();
        println!("x.a: {}", x.a);
    }

    {
        // Create x, which allows modifying the original data and checks for changes when
        // it goes out of scope.
        let mut x = data.as_tracked_mut();
        x.a = 10;
        println!("x.a: {}", x.a);
        // When we leave this scope, changes are detected and sent to the listeners.
    }

}

Trait Implementations

impl<T, K> AsRef<T> for DataTracker<T, K>

where T: Clone + PartialEq, K: Hash + Eq,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.