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
87
88

pub(super) struct DenseIdMap<T> {
    entries: Vec<Option<T>>,
    len: usize,
}

impl<T> Default for DenseIdMap<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T> DenseIdMap<T> {
    pub(super) fn new() -> Self {
        Self {
            entries: Vec::new(),
            len: 0,
        }
    }

    pub(super) fn get(&self, id: usize) -> Option<&T> {
        self.entries.get(id).and_then(Option::as_ref)
    }

    pub(super) fn get_mut(&mut self, id: usize) -> Option<&mut T> {
        self.entries.get_mut(id).and_then(Option::as_mut)
    }

    pub(super) fn insert(&mut self, id: usize, value: T) -> Option<T> {
        self.ensure_index(id);
        let entry = &mut self.entries[id];
        if entry.is_none() {
            self.len += 1;
        }
        entry.replace(value)
    }

    pub(super) fn remove(&mut self, id: usize) -> Option<T> {
        let entry = self.entries.get_mut(id)?;
        let removed = entry.take();
        if removed.is_some() {
            self.len -= 1;
            if id + 1 == self.entries.len() {
                self.trim_trailing_empty();
            }
        }
        removed
    }

    pub(super) fn clear(&mut self) {
        self.entries.clear();
        self.len = 0;
    }

    pub(super) fn len(&self) -> usize {
        self.len
    }

    pub(super) fn capacity(&self) -> usize {
        self.entries.capacity()
    }

    pub(super) fn iter(&self) -> impl Iterator<Item = (usize, &T)> + '_ {
        self.entries
            .iter()
            .enumerate()
            .filter_map(|(id, entry)| entry.as_ref().map(|value| (id, value)))
    }

    pub(super) fn shrink_to_fit(&mut self) {
        self.trim_trailing_empty();
        self.entries.shrink_to_fit();
    }

    fn ensure_index(&mut self, id: usize) {
        if id >= self.entries.len() {
            self.entries.resize_with(id + 1, || None);
        }
    }

    fn trim_trailing_empty(&mut self) {
        let retained = self
            .entries
            .iter()
            .rposition(|entry| entry.is_some())
            .map_or(0, |index| index + 1);
        self.entries.truncate(retained);
    }
}