fgr 0.3.1

Fine-grained reactivity for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

use super::node::{HasNode, NodeWithValue, NodeValRef, NodeValRefMut};
use std::cell::RefCell;
use std::ops::Deref;
use std::ops::DerefMut;
use std::rc::{Rc, Weak};

pub struct Signal<A> {
    data: Rc<NodeWithValue<A>>,
}

impl<A> Clone for Signal<A> {
    fn clone(&self) -> Self {
        Signal {
            data: self.data.clone(),
        }
    }
}

pub fn signal_data<A>(signal: &Signal<A>) -> &Rc<NodeWithValue<A>> {
    &signal.data
}

impl<A:'static> Signal<A> {
    pub fn new(init_value: A) -> Signal<A> {
        let this: Rc<RefCell<Option<Weak<dyn HasNode>>>> = Rc::new(RefCell::new(None));
        let r = Signal {
            data: Rc::new(NodeWithValue::new(this.clone(), init_value))
        };
        *(*this).borrow_mut() = Some(Rc::downgrade(&r.data) as Weak<dyn HasNode>);
        r
    }

    pub fn read<'a>(&'a self) -> impl Deref<Target=A> + 'a {
        NodeValRef::new(&*self.data, self.data.clone())
    }

    pub fn write<'a>(&'a self) -> impl DerefMut<Target=A> + 'a {
        NodeValRefMut::new(&*self.data, self.data.clone())
    }
}