Struct suzy::watch::WatchedEvent

pub struct WatchedEvent<T> { /* fields omitted */ }

A WatchedEvent uses the watch system provided by this crate to implement an event disptacher. This is different from a watched value (Watched) in that events will fire for each value passed to WatchedEvent::dispatch() and will not “store” the data.

use drying_paint::*;

type EventCounter = Watcher<EventCounterData>;

#[derive(Default)]
struct EventCounterData {
    counter: u32,
    add: WatchedEvent<u32>,
}

impl WatcherInit for EventCounterData {
    fn init(watcher: &mut WatcherMeta<Self>) {
        watcher.watch(|root| {
            if let Some(amount) = root.add.bind() {
                root.counter += amount;
            }
        });
    }
}

fn main() {
    let mut ctx = WatchContext::new();
    ctx.with(|| {
        let item = WatchContext::allow_watcher_access((), |()| {
            let mut item = EventCounter::new();
            item.data_mut().add.dispatch(7);
            item
        });
        WatchContext::update_current();
        let item = WatchContext::allow_watcher_access(item, |mut item| {
            assert_eq!(item.data().counter, 7);
            item.data_mut().add.dispatch(9);
            item.data_mut().add.dispatch(3);
            item
        });
        WatchContext::update_current();
        WatchContext::allow_watcher_access(item, |mut item| {
            assert_eq!(item.data().counter, 19);
        });
    });
}

Implementations

impl<T> WatchedEvent<T> where
    T: 'static, 

pub fn new() -> WatchedEvent<T>

Create a new WatchedEvent

pub fn bind(&self) -> Option<&T>

Used inside a watch closure this will return a value each time the event is dispatched

pub fn dispatch(&mut self, arg: T)

Trigger the event. The argument passed will be delivered to listeners.

Trait Implementations

impl<T> Default for WatchedEvent<T> where
    T: 'static, 

pub fn default() -> WatchedEvent<T>

Returns the “default value” for a type.