Removed warning of rustc 1.7.0 complaining about deprecated usage of std::thread...
[rust-101.git] / solutions / src / callbacks.rs
1 use std::rc::Rc;
2 use std::cell::RefCell;
3
4 #[derive(Clone)]
5 pub struct Callbacks {
6     callbacks: Vec<Rc<RefCell<FnMut(i32)>>>,
7 }
8
9 impl Callbacks {
10     pub fn new() -> Self {
11         Callbacks { callbacks: Vec::new() }                      /*@*/
12     }
13
14     pub fn register<F: FnMut(i32)+'static>(&mut self, callback: F) {
15         let cell = Rc::new(RefCell::new(callback));
16         self.callbacks.push(cell);                                  /*@*/
17     }
18
19     pub fn call(&mut self, val: i32) {
20         for callback in self.callbacks.iter() {
21             // We have to *explicitly* borrow the contents of a `RefCell`.
22             //@ At run-time, the cell will keep track of the number of outstanding shared and mutable borrows,
23             //@ and panic if the rules are violated. Since this function is the only one that borrow the
24             //@ environments of the closures, and this function requires a *mutable* borrow of `self`, we know this cannot
25             //@ happen. <br />
26             //@ For this check to be performed, `closure` is a *guard*: Rather than a normal borrow, `borrow_mut` returns
27             //@ a smart pointer (`RefMut`, in this case) that waits until is goes out of scope, and then
28             //@ appropriately updates the number of active borrows.
29             //@ 
30             //@ The function would still typecheck with an immutable borrow of `self` (since we are
31             //@ relying on the interior mutability of `self`), but then it could happen that a callback
32             //@ will in turn trigger another round of callbacks, so that `call` would indirectly call itself.
33             //@ This is called reentrancy. It would imply that we borrow the closure a second time, and
34             //@ panic at run-time. I hope this also makes it clear that there's absolutely no hope of Rust
35             //@ performing these checks statically, at compile-time: It would have to detect reentrancy!
36             let mut closure = callback.borrow_mut();
37             // Unfortunately, Rust's auto-dereference of pointers is not clever enough here. We thus have to explicitly
38             // dereference the smart pointer and obtain a mutable borrow of the target.
39             (&mut *closure)(val);
40         }
41     }
42 }
43
44 #[cfg(test)]
45 mod tests {
46     use std::rc::Rc;
47     use std::cell::RefCell;
48     use super::*;
49
50     #[test]
51     #[should_panic]
52     fn test_reentrant() {
53         let c = Rc::new(RefCell::new(Callbacks::new()));
54         c.borrow_mut().register(|val| println!("Callback called: {}", val) );
55
56         {
57             let c2 = c.clone();
58             c.borrow_mut().register(move |val| {
59                 let mut guard = c2.borrow_mut();
60                 println!("Callback called with {}, ready to go for nested call.", val);
61                 guard.call(val+val)
62             } );
63         }
64
65         // We do a clone, and call `call` on that one. This makes sure that it's not our `RefCell` that complains about two mutable borrows,
66         // but rather the `RefCell` inside the `CallbacksMut`.
67         let mut c2: Callbacks = c.borrow().clone();
68         drop(c);
69         c2.call(42);
70     }
71 }