fermi 0.4.3

Global state management for Dioxus
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::{use_atom_root, AtomId, AtomRef, AtomRoot, Readable};
use dioxus_core::{ScopeId, ScopeState};
use std::{
    cell::{Ref, RefCell, RefMut},
    rc::Rc,
};

///
///
///
///
///
///
///
///
#[must_use]
pub fn use_atom_ref<'a, T: 'static>(
    cx: &'a ScopeState,
    atom: &'static AtomRef<T>,
) -> &'a UseAtomRef<T> {
    let root = use_atom_root(cx);

    &cx.use_hook(|| {
        root.initialize(atom);
        (
            UseAtomRef {
                ptr: atom.unique_id(),
                root: root.clone(),
                scope_id: cx.scope_id(),
                value: root.register(atom, cx.scope_id()),
            },
            AtomRefSubscription {
                ptr: atom.unique_id(),
                root: root.clone(),
                scope_id: cx.scope_id(),
            },
        )
    })
    .0
}

pub struct AtomRefSubscription {
    ptr: AtomId,
    root: Rc<AtomRoot>,
    scope_id: ScopeId,
}

impl Drop for AtomRefSubscription {
    fn drop(&mut self) {
        self.root.unsubscribe(self.ptr, self.scope_id)
    }
}

pub struct UseAtomRef<T> {
    ptr: AtomId,
    value: Rc<RefCell<T>>,
    root: Rc<AtomRoot>,
    scope_id: ScopeId,
}

impl<T> Clone for UseAtomRef<T> {
    fn clone(&self) -> Self {
        Self {
            ptr: self.ptr,
            value: self.value.clone(),
            root: self.root.clone(),
            scope_id: self.scope_id,
        }
    }
}

impl<T: 'static> UseAtomRef<T> {
    pub fn read(&self) -> Ref<T> {
        self.value.borrow()
    }

    /// This is silent operation
    /// call `.force_update()` manually if required
    pub fn with_mut_silent(&self, cb: impl FnOnce(&mut T)) {
        cb(&mut *self.write_silent())
    }

    pub fn write(&self) -> RefMut<T> {
        self.root.force_update(self.ptr);
        self.value.borrow_mut()
    }

    /// Silent write to AtomRef
    /// does not update Subscribed scopes
    pub fn write_silent(&self) -> RefMut<T> {
        self.value.borrow_mut()
    }

    /// Replace old value with new one
    pub fn set(&self, new: T) {
        self.root.force_update(self.ptr);
        self.root.set(self.ptr, new);
    }

    /// Do not update provided context on Write ops
    /// Example:
    /// ```ignore
    /// static ATOM_DATA: AtomRef<Collection> = |_| Default::default();
    /// fn App(cx: Scope) {
    ///     use_init_atom_root(cx);
    ///     let atom_data = use_atom_ref(cx, ATOM_DATA);
    ///     atom_data.unsubscribe(cx);
    ///     atom_data.write().update();
    /// }
    /// ```
    pub fn unsubscribe(&self, cx: &ScopeState) {
        self.root.unsubscribe(self.ptr, cx.scope_id());
    }

    /// Force update of subscribed Scopes
    pub fn force_update(&self) {
        self.root.force_update(self.ptr);
    }
}