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#[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#[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;