Skip to main content

prjcombine_entity/
range_vec.rs

1use crate::{EntityIdArith, EntityRange, EntityVec, entity_id_u32};
2
3entity_id_u32!(RangeId, RangeTag tag, "RANGE");
4
5#[derive(Clone, Debug, PartialEq, Eq, Hash)]
6pub struct EntityRangeVec<I: EntityIdArith, V> {
7    ranges: EntityVec<RangeId, (EntityRange<I>, V)>,
8    items: EntityVec<I, RangeId>,
9}
10
11impl<I: EntityIdArith, V> EntityRangeVec<I, V> {
12    pub fn new() -> Self {
13        Self {
14            ranges: Default::default(),
15            items: Default::default(),
16        }
17    }
18
19    pub fn len(&self) -> usize {
20        self.items.len()
21    }
22
23    pub fn len_ranges(&self) -> usize {
24        self.ranges.len()
25    }
26
27    pub fn is_empty(&self) -> bool {
28        self.items.is_empty()
29    }
30
31    pub fn range(&self, idx: I) -> EntityRange<I> {
32        self.ranges[self.items[idx]].0
33    }
34
35    pub fn clear(&mut self) {
36        self.ranges.clear();
37        self.items.clear();
38    }
39
40    pub fn ids(&self) -> EntityRange<I> {
41        self.items.ids()
42    }
43
44    pub fn next_id(&self) -> I {
45        self.items.next_id()
46    }
47
48    pub fn values(&self) -> impl DoubleEndedIterator<Item = &V> + ExactSizeIterator {
49        self.ranges.values().map(|(_, v)| v)
50    }
51
52    pub fn values_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut V> + ExactSizeIterator {
53        self.ranges.values_mut().map(|(_, v)| v)
54    }
55
56    pub fn into_values(self) -> impl DoubleEndedIterator<Item = V> + ExactSizeIterator {
57        self.ranges.into_values().map(|(_, v)| v)
58    }
59
60    pub fn iter(&self) -> Iter<'_, I, V> {
61        Iter {
62            inner: self.ranges.values(),
63        }
64    }
65
66    pub fn iter_mut(&mut self) -> IterMut<'_, I, V> {
67        IterMut {
68            inner: self.ranges.values_mut(),
69        }
70    }
71
72    pub fn inner_separators(&self) -> impl DoubleEndedIterator<Item = I> + ExactSizeIterator {
73        self.ranges.values().skip(1).map(|&(r, _)| r.start())
74    }
75
76    pub fn push(&mut self, num: usize, val: V) -> EntityRange<I> {
77        let range = self.items.next_id().range_up(num);
78        if num != 0 {
79            let rid = self.ranges.push((range, val));
80            for _ in 0..num {
81                self.items.push(rid);
82            }
83        }
84        assert_eq!(self.items.next_id(), range.end());
85        range
86    }
87}
88
89impl<I: EntityIdArith, V> Default for EntityRangeVec<I, V> {
90    fn default() -> Self {
91        Self::new()
92    }
93}
94
95impl<I: EntityIdArith, V> core::ops::Index<I> for EntityRangeVec<I, V> {
96    type Output = V;
97
98    fn index(&self, index: I) -> &Self::Output {
99        &self.ranges[self.items[index]].1
100    }
101}
102
103impl<I: EntityIdArith, V> core::ops::IndexMut<I> for EntityRangeVec<I, V> {
104    fn index_mut(&mut self, index: I) -> &mut Self::Output {
105        &mut self.ranges[self.items[index]].1
106    }
107}
108
109impl<I: EntityIdArith, V> IntoIterator for EntityRangeVec<I, V> {
110    type Item = (EntityRange<I>, V);
111
112    type IntoIter = std::vec::IntoIter<(EntityRange<I>, V)>;
113
114    fn into_iter(self) -> Self::IntoIter {
115        self.ranges.into_values()
116    }
117}
118
119impl<'a, I: EntityIdArith, V> IntoIterator for &'a EntityRangeVec<I, V> {
120    type Item = (EntityRange<I>, &'a V);
121
122    type IntoIter = Iter<'a, I, V>;
123
124    fn into_iter(self) -> Self::IntoIter {
125        self.iter()
126    }
127}
128
129impl<'a, I: EntityIdArith, V> IntoIterator for &'a mut EntityRangeVec<I, V> {
130    type Item = (EntityRange<I>, &'a mut V);
131
132    type IntoIter = IterMut<'a, I, V>;
133
134    fn into_iter(self) -> Self::IntoIter {
135        self.iter_mut()
136    }
137}
138
139/// Iterator of `(range, &value)` pairs.
140#[derive(Clone, Debug)]
141pub struct Iter<'a, I: EntityIdArith, V> {
142    inner: core::slice::Iter<'a, (EntityRange<I>, V)>,
143}
144
145impl<'a, I: EntityIdArith, V> Iterator for Iter<'a, I, V> {
146    type Item = (EntityRange<I>, &'a V);
147    fn next(&mut self) -> Option<(EntityRange<I>, &'a V)> {
148        let &(ids, ref val) = self.inner.next()?;
149        Some((ids, val))
150    }
151}
152
153impl<'a, I: EntityIdArith, V> DoubleEndedIterator for Iter<'a, I, V> {
154    fn next_back(&mut self) -> Option<(EntityRange<I>, &'a V)> {
155        let &(ids, ref val) = self.inner.next_back()?;
156        Some((ids, val))
157    }
158}
159
160impl<'a, I: EntityIdArith, V> ExactSizeIterator for Iter<'a, I, V> {
161    fn len(&self) -> usize {
162        self.inner.len()
163    }
164}
165
166/// Iterator of `(id, &mut value)` pairs.
167#[derive(Debug)]
168pub struct IterMut<'a, I: EntityIdArith, V> {
169    inner: core::slice::IterMut<'a, (EntityRange<I>, V)>,
170}
171
172impl<'a, I: EntityIdArith, V> Iterator for IterMut<'a, I, V> {
173    type Item = (EntityRange<I>, &'a mut V);
174    fn next(&mut self) -> Option<(EntityRange<I>, &'a mut V)> {
175        let &mut (ids, ref mut val) = self.inner.next()?;
176        Some((ids, val))
177    }
178}
179
180impl<'a, I: EntityIdArith, V> DoubleEndedIterator for IterMut<'a, I, V> {
181    fn next_back(&mut self) -> Option<(EntityRange<I>, &'a mut V)> {
182        let &mut (ids, ref mut val) = self.inner.next_back()?;
183        Some((ids, val))
184    }
185}
186
187impl<'a, I: EntityIdArith, V> ExactSizeIterator for IterMut<'a, I, V> {
188    fn len(&self) -> usize {
189        self.inner.len()
190    }
191}
192
193#[cfg(feature = "bincode")]
194mod bincode;