windows-reactor 0.100.0

Declarative Windows UI 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
76
77
78
79
80

use std::cmp::Reverse;

use super::*;

impl<R: NativeRuntime> Pump<R> {
    pub(super) fn prepare_component_effects(&self, changes: &ComponentChanges) {
        let cleanup = changes
            .retired
            .iter()
            .chain(changes.composed.iter())
            .copied()
            .filter(|token| !changes.reserved.contains(token))
            .collect::<HashSet<_>>();
        let retired = changes.retired.iter().copied().collect::<HashSet<_>>();
        let mut ordered = cleanup
            .into_iter()
            .map(|token| {
                let node = self.tree.component_node(token.scope()).unwrap();
                (Reverse(self.tree.depth(node)), node, token)
            })
            .collect::<Vec<_>>();
        ordered.sort_unstable_by(|left, right| (&left.0, &left.1).cmp(&(&right.0, &right.1)));
        for (_, _, token) in ordered {
            if retired.contains(&token) {
                self.components.cleanup_effects(token);
            } else {
                self.components.prepare_effects(token);
            }
        }
    }

    pub(super) fn commit_component_effects(&self, changes: &ComponentChanges) {
        let retired = changes.retired.iter().copied().collect::<HashSet<_>>();
        let setup = changes
            .reserved
            .iter()
            .chain(changes.composed.iter())
            .copied()
            .filter(|token| !retired.contains(token))
            .collect::<HashSet<_>>();
        let mut ordered = setup
            .into_iter()
            .map(|token| {
                let node = self.tree.component_node(token.scope()).unwrap();
                (self.tree.depth(node), node, token)
            })
            .collect::<Vec<_>>();
        ordered.sort_unstable_by(|left, right| (&left.0, &left.1).cmp(&(&right.0, &right.1)));
        for (_, _, token) in ordered {
            self.components.commit_effects(token);
        }
    }

    pub(super) fn finalize_component_changes(&mut self, changes: &ComponentChanges) {
        let retired = changes.retired.iter().copied().collect::<HashSet<_>>();
        for token in changes.reserved.iter().copied() {
            if !retired.contains(&token) {
                self.components.publish(token);
            }
        }
        for (token, dependencies) in &changes.context_reads {
            if !retired.contains(token) {
                self.components
                    .set_context_dependencies(*token, dependencies.clone());
            }
        }
        for token in changes.retired.iter().copied() {
            self.components.remove(token);
        }
    }

    pub(super) fn remove_reservations(
        components: &mut ComponentStore,
        reserved: &[ComponentToken],
    ) {
        for token in reserved.iter().rev().copied() {
            components.remove(token);
        }
    }
}