cranpose-core 0.0.60

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

#[cfg(any(test, debug_assertions))]
mod anchors;
#[cfg(any(test, debug_assertions))]
mod detached;
#[cfg(any(test, debug_assertions))]
mod errors;
#[cfg(any(test, debug_assertions))]
mod groups;
#[cfg(any(test, debug_assertions))]
mod nodes;
#[cfg(any(test, debug_assertions))]
mod payloads;
#[cfg(any(test, debug_assertions))]
mod scopes;
#[cfg(any(test, debug_assertions))]
mod writer;

use super::SlotTable;
#[cfg(any(test, debug_assertions))]
pub(crate) use errors::{PayloadAnchorRecord, SlotInvariantError, SlotTreeContext};
#[cfg(any(test, debug_assertions))]
use groups::{validate_slot_tree, ActiveSlotTreeChecks, SlotTreeView};

impl SlotTable {
    #[track_caller]
    pub(crate) fn assert_fast_integrity(&self, context: &'static str) {
        assert_eq!(
            self.anchors.active_len(),
            self.groups.len(),
            "slot table active group anchor count mismatch after {context}"
        );
        assert_eq!(
            self.payload_anchors.active_len(),
            self.payloads.len(),
            "slot table active payload anchor count mismatch after {context}"
        );
        assert!(
            self.scope_index.len() <= self.groups.len(),
            "slot table scope index has more entries than active groups after {context}"
        );
    }
}

#[cfg(any(test, debug_assertions))]
impl SlotTable {
    pub(crate) fn debug_verify(&self) {
        if crate::slot_validation_diagnostics_enabled() {
            if let Err(err) = self.validate() {
                panic!("slot table invariant violation: {err:?}");
            }
        }
    }

    pub(in crate::slot) fn debug_assert_valid_after(&self, operation: &'static str) {
        if crate::slot_validation_diagnostics_enabled() {
            if let Err(err) = self.validate() {
                panic!("slot table invariant violation after {operation}: {err:?}");
            }
        } else {
            self.assert_fast_integrity(operation);
        }
    }

    pub(crate) fn validate(&self) -> Result<(), SlotInvariantError> {
        let mut checks = ActiveSlotTreeChecks::new(self);
        validate_slot_tree(
            SlotTreeView {
                tree: SlotTreeContext::Active,
                groups: &self.groups,
                payloads: &self.payloads,
                nodes: &self.nodes,
            },
            &mut checks,
        )?;

        anchors::validate_anchor_registry_integrity(self)?;
        anchors::validate_active_group_anchor_count(self)?;
        anchors::validate_active_group_anchor_entries(self)?;
        payloads::validate_payload_anchor_registry_integrity(self)?;
        payloads::validate_payload_anchor_registry_count(self)?;
        scopes::validate_scope_index_count(self)?;
        payloads::validate_payload_anchor_registry(self)?;

        Ok(())
    }
}