[][src]Crate drying_paint

The name 'drying_paint' comes from the expression "watching paint dry". This module provides a system to "watch" some values for changes and run code whenever they change.

The typical usage is as follows: you first define a structure to hold data, including some "watched" data.

struct HelloData {
    name: Watched<String>,
    greeting: String,

Implementing the trait WatcherInit for that structure gives you an place to set-up the code that should run when a watched value changes.

impl WatcherInit for HelloData {
    fn init(watcher: &mut WatcherMeta<Self>) {
        watcher.watch(|root| {
            root.greeting = format!("Hello, {}!", root.name);

Normally you need to wrap the data struct in a Watcher, so it's common to alias the watcher type to cleanup the syntax a bit:

type Hello = Watcher<HelloData>;

Creating watchers and setting watched data needs to happen within a WatchContext. WatchContext::update_current() will cause all the pending watcher code to run.

fn main() {
    let mut ctx = WatchContext::new();
    ctx.with(|| {
        let mut obj = Hello::new();
        *obj.data_mut().name = "Rust".to_string();
        assert_eq!(obj.data().greeting, "Hello, Rust!");



An ergonomic wrapper for binding to an WatchedEvent. This is expected to be used from within a WatcherInit implementation.



Most of the functions in this crate require that they are executing in a context. The context keeps track of some "global" state which enables the functionality in this crate.


This represents some value which will be interesting to watch. Watcher functions that reference this value will be re-run when this value changes.


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. A bind_event macro is provided for convience, and is the preferred way to watch an event:


This provides the basic functionality behind watched values. You can use it to provide functionality using the watch system for cases where Watched and WatchedEvent are not appropriate.


Watcher is a structure designed to hold some data along with associated functions which will run when watched data changes.


This structure is used internally by Watcher. It is passed to the init function of WatcherInit, the trait which is required to be implemented by the data stored in Watchers.



This trait is required to be implemented by the data stored in Watchers. It provides a convient point to register watching functions.