cranpose-core 0.1.9

Core runtime for a Jetpack Compose inspired UI framework in 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
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 super::debug::SlotTableDiagnostics;
use super::{
    AnchorRegistry, DeferredDrop, GroupRecord, NodeRecord, PayloadAnchorRegistry, PayloadRecord,
    ScopeIndex, SlotLifecycleCoordinator, SlotWriteSessionState,
};
use std::rc::Rc;

mod metadata;
mod mutation;
mod values;

#[cfg(test)]
pub(crate) use values::ValueSlotError;

struct SlotStorageIdentity(Rc<()>);

impl SlotStorageIdentity {
    fn new() -> Self {
        Self(Rc::new(()))
    }

    fn id(&self) -> usize {
        Rc::as_ptr(&self.0).addr()
    }
}

pub(crate) struct SlotWriteSession<'a> {
    pub(super) table: &'a mut SlotTable,
    pub(in crate::slot) lifecycle: &'a mut SlotLifecycleCoordinator,
    pub(in crate::slot) state: &'a mut SlotWriteSessionState,
}

pub struct SlotTable {
    storage_id: SlotStorageIdentity,
    pub(super) groups: Vec<GroupRecord>,
    pub(super) payloads: Vec<PayloadRecord>,
    pub(super) nodes: Vec<NodeRecord>,
    pub(super) anchors: AnchorRegistry,
    pub(super) payload_anchors: PayloadAnchorRegistry,
    pub(super) scope_index: ScopeIndex,
    pub(super) diagnostics: SlotTableDiagnostics,
    next_group_generation: u32,
}

impl SlotTable {
    pub fn new() -> Self {
        Self {
            storage_id: SlotStorageIdentity::new(),
            groups: Vec::new(),
            payloads: Vec::new(),
            nodes: Vec::new(),
            anchors: AnchorRegistry::new(),
            payload_anchors: PayloadAnchorRegistry::new(),
            scope_index: ScopeIndex::new(),
            diagnostics: SlotTableDiagnostics::default(),
            next_group_generation: 1,
        }
    }

    pub(crate) fn write_session<'a>(
        &'a mut self,
        lifecycle: &'a mut SlotLifecycleCoordinator,
        state: &'a mut SlotWriteSessionState,
    ) -> SlotWriteSession<'a> {
        SlotWriteSession {
            table: self,
            lifecycle,
            state,
        }
    }

    pub(crate) fn storage_id(&self) -> usize {
        self.storage_id.id()
    }

    #[cfg(test)]
    pub(in crate::slot) fn set_next_group_generation_for_test(&mut self, generation: u32) {
        self.next_group_generation = generation;
    }

    #[cfg(test)]
    pub(in crate::slot) fn set_next_group_anchor_for_test(&mut self, next_anchor: usize) {
        self.anchors.set_next_anchor_for_test(next_anchor);
    }

    #[cfg(test)]
    pub(in crate::slot) fn set_next_payload_anchor_for_test(&mut self, next_anchor: usize) {
        self.payload_anchors.set_next_id_for_test(next_anchor);
    }

    pub(crate) fn compact_storage(&mut self) {
        self.groups.shrink_to_fit();
        self.payloads.shrink_to_fit();
        self.nodes.shrink_to_fit();
        self.anchors.shrink_to_fit();
        self.payload_anchors.shrink_to_fit();
        self.scope_index.shrink_to_fit();
    }

    pub(crate) fn take_all_drops(&mut self) -> Vec<DeferredDrop> {
        let payload_count = self.payloads.len();
        let mut drops = Vec::with_capacity(payload_count);
        for payload in self.payloads.drain(..).rev() {
            drops.push(payload.into_deferred_drop());
        }
        self.groups.clear();
        self.nodes.clear();
        self.anchors.clear();
        self.payload_anchors.clear();
        self.scope_index.clear();
        drops
    }
}

impl Default for SlotTable {
    fn default() -> Self {
        Self::new()
    }
}