frappe 0.4.7

Functional Reactive Programming library 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! Storage cell used by Signal.

use crate::sync::RwLock;

/// Storage cell for shared signal values.
pub struct Storage<T> {
    val: RwLock<Option<T>>,
}

const ERR_EMPTY: &str = "storage empty";

impl<T> Storage<T> {
    /// Creates a storage with an initial value.
    pub fn new(val: T) -> Self {
        Storage {
            val: RwLock::new(Some(val)),
        }
    }

    /// Gets the value by cloning.
    pub fn get(&self) -> T
    where
        T: Clone,
    {
        self.val.read().clone().expect(ERR_EMPTY)
    }

    /// Sets the value.
    pub fn set(&self, val: T) {
        *self.val.write() = Some(val);
    }

    /// Maps the stored value in place.
    pub fn replace<F>(&self, f: F)
    where
        F: FnOnce(T) -> T,
    {
        let mut st = self.val.write();
        let old = st.take().expect(ERR_EMPTY);
        *st = Some(f(old));
    }

    /// Same as `replace` but it also returns the new value.
    pub fn replace_fetch<F>(&self, f: F) -> T
    where
        F: FnOnce(T) -> T,
        T: Clone,
    {
        let mut st = self.val.write();
        let old = st.take().expect(ERR_EMPTY);
        let new = f(old);
        *st = Some(new.clone());
        new
    }

    /// A `replace` version with cloning.
    pub fn replace_clone<F>(&self, f: F)
    where
        F: FnOnce(T) -> T,
        T: Clone,
    {
        let mut st = self.val.write();
        let old = st.clone().expect(ERR_EMPTY);
        *st = Some(f(old));
    }
}

impl<T> Default for Storage<T> {
    /// Creates an empty storage.
    fn default() -> Self {
        Storage {
            val: Default::default(),
        }
    }
}