vertigo 0.11.3

Reactive Real-DOM library with SSR 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

use super::inner_value::InnerValue;

#[derive(Debug)]
pub struct ValueMut<T> {
    value: InnerValue<T>,
}

impl<T> ValueMut<T> {
    pub fn new(value: T) -> ValueMut<T> {
        ValueMut {
            value: InnerValue::new(value),
        }
    }

    pub fn set(&self, value: T) {
        *self.value.get_mut() = value;
    }

    pub fn map<K>(&self, fun: impl Fn(&T) -> K) -> K {
        fun(self.value.get())
    }

    pub fn change<R>(&self, change: impl FnOnce(&mut T) -> R) -> R {
        change(self.value.get_mut())
    }
}

impl<T: Default> Default for ValueMut<T> {
    fn default() -> Self {
        Self {
            value: InnerValue::new(Default::default()),
        }
    }
}

impl<T: Default> ValueMut<T> {
    pub fn move_to<R>(&self, change: impl Fn(T) -> (T, R)) -> R {
        let state = self.value.get_mut();
        let prev_state = std::mem::take::<T>(state);
        let (new_state, rest) = change(prev_state);
        let _ = std::mem::replace::<T>(state, new_state);
        rest
    }

    pub fn move_to_void(&self, change: impl Fn(T) -> T) {
        let state = self.value.get_mut();
        let prev_state = std::mem::take::<T>(state);
        let new_state = change(prev_state);
        let _ = std::mem::replace::<T>(state, new_state);
    }
}

impl<T: Clone> ValueMut<T> {
    pub fn get(&self) -> T {
        let state = self.value.get();
        (*state).clone()
    }
}

impl<T: PartialEq> ValueMut<T> {
    pub fn set_if_changed(&self, value: T) -> bool {
        let state = self.value.get_mut();
        if *state != value {
            *state = value;
            true
        } else {
            false
        }
    }
}