1use core::hash::Hash;
2use core::marker::PhantomData;
3use core::ops::{Index, IndexMut};
4
5use std::fmt;
6
7use crate::{EntityId, EntityVec};
8
9#[derive(Clone, Eq, PartialEq, Hash)]
10#[cfg_attr(feature = "bincode", derive(bincode::Encode, bincode::Decode))]
11pub struct EntityPartVec<I: EntityId, V> {
12 vals: Vec<Option<V>>,
13 ids: PhantomData<I>,
14}
15
16impl<I: EntityId, V> EntityPartVec<I, V> {
17 pub fn new() -> Self {
18 Self {
19 vals: Vec::new(),
20 ids: PhantomData,
21 }
22 }
23
24 pub fn with_capacity(cap: usize) -> Self {
25 Self {
26 vals: Vec::with_capacity(cap),
27 ids: PhantomData,
28 }
29 }
30
31 pub fn get(&self, id: I) -> Option<&V> {
32 let idx = id.to_idx();
33 self.vals.get(idx).and_then(|x| x.as_ref())
34 }
35
36 pub fn get_mut(&mut self, id: I) -> Option<&mut V> {
37 let idx = id.to_idx();
38 self.vals.get_mut(idx).and_then(|x| x.as_mut())
39 }
40
41 pub fn contains_id(&self, id: I) -> bool {
42 let idx = id.to_idx();
43 self.vals.get(idx).map_or(false, |x| x.is_some())
44 }
45
46 pub fn clear(&mut self) {
47 self.vals.clear()
48 }
49
50 pub fn insert(&mut self, id: I, val: V) -> Option<V> {
51 let idx = id.to_idx();
52 if idx >= self.vals.len() {
53 self.vals.resize_with(idx + 1, Default::default);
54 }
55 std::mem::replace(&mut self.vals[idx], Some(val))
56 }
57
58 pub fn remove(&mut self, id: I) -> Option<V> {
59 let idx = id.to_idx();
60 let res = self.vals.get_mut(idx)?.take();
61 while let Some(None) = self.vals.last() {
62 self.vals.pop();
63 }
64 res
65 }
66
67 pub fn ids(&self) -> Ids<'_, I, V> {
68 Ids { vals: self.iter() }
69 }
70
71 pub fn into_ids(self) -> IntoIds<I, V> {
72 IntoIds {
73 vals: self.into_iter(),
74 }
75 }
76
77 pub fn iter(&self) -> Iter<'_, I, V> {
78 Iter {
79 vals: self.vals.iter(),
80 pos: 0,
81 ids: PhantomData,
82 }
83 }
84
85 pub fn iter_mut(&mut self) -> IterMut<'_, I, V> {
86 IterMut {
87 vals: self.vals.iter_mut(),
88 pos: 0,
89 ids: PhantomData,
90 }
91 }
92
93 pub fn values(&self) -> Values<'_, I, V> {
94 Values { vals: self.iter() }
95 }
96
97 pub fn values_mut(&mut self) -> ValuesMut<'_, I, V> {
98 ValuesMut {
99 vals: self.iter_mut(),
100 }
101 }
102
103 pub fn into_values(self) -> IntoValues<I, V> {
104 IntoValues {
105 vals: self.into_iter(),
106 }
107 }
108
109 pub fn into_full(mut self) -> EntityVec<I, V> {
110 while matches!(self.vals.last(), Some(None)) {
111 self.vals.pop();
112 }
113 self.vals.into_iter().map(Option::unwrap).collect()
114 }
115
116 pub fn try_into_full(mut self) -> Result<EntityVec<I, V>, I> {
117 while matches!(self.vals.last(), Some(None)) {
118 self.vals.pop();
119 }
120 let mut res = EntityVec::new();
121 for val in self.vals {
122 if let Some(val) = val {
123 res.push(val);
124 } else {
125 return Err(res.next_id());
126 }
127 }
128 Ok(res)
129 }
130}
131
132impl<I: EntityId, V> Default for EntityPartVec<I, V> {
133 fn default() -> Self {
134 Self::new()
135 }
136}
137
138impl<I, V> fmt::Debug for EntityPartVec<I, V>
139where
140 I: EntityId,
141 V: fmt::Debug,
142{
143 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
144 fmt.debug_map().entries(self).finish()
145 }
146}
147
148impl<I: EntityId, V> IntoIterator for EntityPartVec<I, V> {
149 type Item = (I, V);
150 type IntoIter = IntoIter<I, V>;
151 fn into_iter(self) -> Self::IntoIter {
152 IntoIter {
153 vals: self.vals.into_iter(),
154 pos: 0,
155 ids: PhantomData,
156 }
157 }
158}
159
160impl<'a, I: EntityId, V> IntoIterator for &'a EntityPartVec<I, V> {
161 type Item = (I, &'a V);
162 type IntoIter = Iter<'a, I, V>;
163 fn into_iter(self) -> Self::IntoIter {
164 self.iter()
165 }
166}
167
168impl<'a, I: EntityId, V> IntoIterator for &'a mut EntityPartVec<I, V> {
169 type Item = (I, &'a mut V);
170 type IntoIter = IterMut<'a, I, V>;
171 fn into_iter(self) -> Self::IntoIter {
172 self.iter_mut()
173 }
174}
175
176impl<I: EntityId, V> Index<I> for EntityPartVec<I, V> {
177 type Output = V;
178 fn index(&self, index: I) -> &V {
179 self.vals[index.to_idx()].as_ref().unwrap()
180 }
181}
182
183impl<I: EntityId, V> IndexMut<I> for EntityPartVec<I, V> {
184 fn index_mut(&mut self, index: I) -> &mut V {
185 self.vals[index.to_idx()].as_mut().unwrap()
186 }
187}
188
189#[derive(Clone, Debug)]
190pub struct Iter<'a, I, V> {
191 vals: core::slice::Iter<'a, Option<V>>,
192 pos: usize,
193 ids: PhantomData<I>,
194}
195
196impl<'a, I: EntityId, V> Iterator for Iter<'a, I, V> {
197 type Item = (I, &'a V);
198 fn next(&mut self) -> Option<(I, &'a V)> {
199 loop {
200 let id = I::from_idx(self.pos);
201 let val = self.vals.next()?;
202 self.pos += 1;
203 if let Some(val) = val {
204 return Some((id, val));
205 }
206 }
207 }
208}
209
210impl<'a, I: EntityId, V> DoubleEndedIterator for Iter<'a, I, V> {
211 fn next_back(&mut self) -> Option<(I, &'a V)> {
212 loop {
213 if let Some(val) = self.vals.next_back()? {
214 return Some((I::from_idx(self.pos + self.vals.len()), val));
215 }
216 }
217 }
218}
219
220#[derive(Debug)]
221pub struct IterMut<'a, I, V> {
222 vals: core::slice::IterMut<'a, Option<V>>,
223 pos: usize,
224 ids: PhantomData<I>,
225}
226
227impl<'a, I: EntityId, V> Iterator for IterMut<'a, I, V> {
228 type Item = (I, &'a mut V);
229 fn next(&mut self) -> Option<(I, &'a mut V)> {
230 loop {
231 let id = I::from_idx(self.pos);
232 let val = self.vals.next()?;
233 self.pos += 1;
234 if let Some(val) = val {
235 return Some((id, val));
236 }
237 }
238 }
239}
240
241impl<'a, I: EntityId, V> DoubleEndedIterator for IterMut<'a, I, V> {
242 fn next_back(&mut self) -> Option<(I, &'a mut V)> {
243 loop {
244 if let Some(val) = self.vals.next_back()? {
245 return Some((I::from_idx(self.pos + self.vals.len()), val));
246 }
247 }
248 }
249}
250
251#[derive(Clone, Debug)]
252pub struct IntoIter<I, V> {
253 vals: std::vec::IntoIter<Option<V>>,
254 pos: usize,
255 ids: PhantomData<I>,
256}
257
258impl<I: EntityId, V> Iterator for IntoIter<I, V> {
259 type Item = (I, V);
260 fn next(&mut self) -> Option<(I, V)> {
261 loop {
262 let id = I::from_idx(self.pos);
263 let val = self.vals.next()?;
264 self.pos += 1;
265 if let Some(val) = val {
266 return Some((id, val));
267 }
268 }
269 }
270}
271
272impl<I: EntityId, V> DoubleEndedIterator for IntoIter<I, V> {
273 fn next_back(&mut self) -> Option<(I, V)> {
274 loop {
275 if let Some(val) = self.vals.next_back()? {
276 return Some((I::from_idx(self.pos + self.vals.len()), val));
277 }
278 }
279 }
280}
281
282#[derive(Clone, Debug)]
283pub struct Ids<'a, I, V> {
284 vals: Iter<'a, I, V>,
285}
286
287impl<'a, I: EntityId, V> Iterator for Ids<'a, I, V> {
288 type Item = I;
289 fn next(&mut self) -> Option<I> {
290 self.vals.next().map(|x| x.0)
291 }
292}
293
294impl<'a, I: EntityId, V> DoubleEndedIterator for Ids<'a, I, V> {
295 fn next_back(&mut self) -> Option<I> {
296 self.vals.next_back().map(|x| x.0)
297 }
298}
299
300#[derive(Clone, Debug)]
301pub struct IntoIds<I, V> {
302 vals: IntoIter<I, V>,
303}
304
305impl<I: EntityId, V> Iterator for IntoIds<I, V> {
306 type Item = I;
307 fn next(&mut self) -> Option<I> {
308 self.vals.next().map(|x| x.0)
309 }
310}
311
312impl<I: EntityId, V> DoubleEndedIterator for IntoIds<I, V> {
313 fn next_back(&mut self) -> Option<I> {
314 self.vals.next_back().map(|x| x.0)
315 }
316}
317
318#[derive(Clone, Debug)]
319pub struct Values<'a, I, V> {
320 vals: Iter<'a, I, V>,
321}
322
323impl<'a, I: EntityId, V> Iterator for Values<'a, I, V> {
324 type Item = &'a V;
325 fn next(&mut self) -> Option<&'a V> {
326 self.vals.next().map(|x| x.1)
327 }
328}
329
330impl<'a, I: EntityId, V> DoubleEndedIterator for Values<'a, I, V> {
331 fn next_back(&mut self) -> Option<&'a V> {
332 self.vals.next_back().map(|x| x.1)
333 }
334}
335
336#[derive(Debug)]
337pub struct ValuesMut<'a, I, V> {
338 vals: IterMut<'a, I, V>,
339}
340
341impl<'a, I: EntityId, V> Iterator for ValuesMut<'a, I, V> {
342 type Item = &'a mut V;
343 fn next(&mut self) -> Option<&'a mut V> {
344 self.vals.next().map(|x| x.1)
345 }
346}
347
348impl<'a, I: EntityId, V> DoubleEndedIterator for ValuesMut<'a, I, V> {
349 fn next_back(&mut self) -> Option<&'a mut V> {
350 self.vals.next_back().map(|x| x.1)
351 }
352}
353
354#[derive(Clone, Debug)]
355pub struct IntoValues<I, V> {
356 vals: IntoIter<I, V>,
357}
358
359impl<I: EntityId, V> Iterator for IntoValues<I, V> {
360 type Item = V;
361 fn next(&mut self) -> Option<V> {
362 self.vals.next().map(|x| x.1)
363 }
364}
365
366impl<I: EntityId, V> DoubleEndedIterator for IntoValues<I, V> {
367 fn next_back(&mut self) -> Option<V> {
368 self.vals.next_back().map(|x| x.1)
369 }
370}
371
372impl<I: EntityId, V> FromIterator<(I, V)> for EntityPartVec<I, V> {
373 fn from_iter<T>(iter: T) -> Self
374 where
375 T: IntoIterator<Item = (I, V)>,
376 {
377 let mut res = Self::new();
378 for (k, v) in iter {
379 res.insert(k, v);
380 }
381 res
382 }
383}
384
385impl<I: EntityId, V> Extend<(I, V)> for EntityPartVec<I, V> {
386 fn extend<T>(&mut self, iter: T)
387 where
388 T: IntoIterator<Item = (I, V)>,
389 {
390 for (k, v) in iter {
391 self.insert(k, v);
392 }
393 }
394}
395
396#[cfg(feature = "serde")]
397mod serde;