The main item of interest is the struct ChangeTracker. Create a new
ChangeTracker that takes ownership of an object of type T. You can then
create a futures::Stream (with get_changes()) that gets a new value upon
every change to the value. The value can be changed with the modify()
method of ChangeTracker and read using the as_ref() method.
This is the successor of raii-change-tracker.
```rust extern crate asyncchangetracker; extern crate futures; extern crate tokio;
use futures::Stream;
// Wrap an integer with ChangeTracker
let mut changetracker = asyncchange_tracker::ChangeTracker::new( 123 );
// Create an receiver that fires when the value changes let rx = changetracker.getchanges(1);
// In this example, upon change, check the old and new value are correct.
let rxprinter = rx.foreach(|(oldvalue, newvalue)| {
asserteq!( oldvalue, 123);
asserteq!( newvalue, 124);
// Here in this example, we return error to abort the stream.
// In normal usage, typically an Ok value would be returned.
futures::future::err(())
});
// Now, check and then change the value. changetracker.modify(|scopedstore| { asserteq!(*scopedstore, 123); *scoped_store += 1; });
// Wait until the stream is done. match tokio::runtime::currentthread::blockonall(rxprinter) { Ok(_) => panic!("should not get here"), Err(()) => (), }
// Finally, check that the final value is as expected. assert!(*changetracker.asref() == 124); ```