id_sys/
id_vec.rs

1use crate::{IdArray, IdSlice, IdSliceIndex, UsizeId};
2use std::{
3    borrow::{Borrow, BorrowMut},
4    cmp::Ordering,
5    fmt::{self, Debug},
6    hash::{Hash, Hasher},
7    marker::PhantomData,
8    mem::transmute,
9    ops::{Deref, DerefMut, Index, IndexMut},
10};
11
12pub struct IdVec<TMarker: ?Sized, TValue> {
13    phantom: PhantomData<TMarker>,
14    repr: Vec<TValue>,
15}
16
17impl<TMarker: ?Sized, TValue> IdVec<TMarker, TValue> {
18    pub fn as_mut_id_slice(&mut self) -> &mut IdSlice<TMarker, TValue> {
19        IdSlice::from_mut_slice(&mut self.repr)
20    }
21
22    pub fn as_mut_vec(&mut self) -> &mut Vec<TValue> {
23        &mut self.repr
24    }
25
26    pub fn as_id_slice(&self) -> &IdSlice<TMarker, TValue> {
27        IdSlice::from_slice(&self.repr)
28    }
29
30    pub const fn as_vec(&self) -> &Vec<TValue> {
31        &self.repr
32    }
33
34    pub fn end(&self) -> UsizeId<TMarker> {
35        self.as_id_slice().end()
36    }
37
38    pub fn from_mut_vec(vec: &mut Vec<TValue>) -> &mut Self {
39        unsafe { transmute(vec) }
40    }
41
42    pub const fn from_vec(vec: Vec<TValue>) -> Self {
43        Self {
44            phantom: PhantomData,
45            repr: vec,
46        }
47    }
48
49    pub const fn from_vec_ref(vec: &Vec<TValue>) -> &Self {
50        unsafe { transmute(vec) }
51    }
52
53    pub fn into_vec(self) -> Vec<TValue> {
54        self.repr
55    }
56
57    pub fn is_empty(&self) -> bool {
58        self.repr.is_empty()
59    }
60
61    pub fn len(&self) -> usize {
62        self.repr.len()
63    }
64
65    pub const fn new() -> Self {
66        Self::from_vec(Vec::new())
67    }
68
69    pub fn push(&mut self, value: TValue) -> UsizeId<TMarker> {
70        let res = self.end();
71        self.repr.push(value);
72        res
73    }
74
75    pub fn resize(&mut self, new_len: usize, value: TValue)
76    where
77        TValue: Clone,
78    {
79        self.repr.resize(new_len, value)
80    }
81}
82
83impl<TMarker: ?Sized, TValue> AsMut<IdSlice<TMarker, TValue>> for IdVec<TMarker, TValue> {
84    fn as_mut(&mut self) -> &mut IdSlice<TMarker, TValue> {
85        self.as_mut_id_slice()
86    }
87}
88
89impl<TMarker: ?Sized, TValue> AsMut<IdVec<TMarker, TValue>> for IdVec<TMarker, TValue> {
90    fn as_mut(&mut self) -> &mut IdVec<TMarker, TValue> {
91        self
92    }
93}
94
95impl<TMarker: ?Sized, TValue> AsRef<IdSlice<TMarker, TValue>> for IdVec<TMarker, TValue> {
96    fn as_ref(&self) -> &IdSlice<TMarker, TValue> {
97        self.as_id_slice()
98    }
99}
100
101impl<TMarker: ?Sized, TValue> AsRef<IdVec<TMarker, TValue>> for IdVec<TMarker, TValue> {
102    fn as_ref(&self) -> &IdVec<TMarker, TValue> {
103        self
104    }
105}
106
107impl<TMarker: ?Sized, TValue> Borrow<IdSlice<TMarker, TValue>> for IdVec<TMarker, TValue> {
108    fn borrow(&self) -> &IdSlice<TMarker, TValue> {
109        IdSlice::from_slice(self.as_vec().borrow())
110    }
111}
112
113impl<TMarker: ?Sized, TValue> BorrowMut<IdSlice<TMarker, TValue>> for IdVec<TMarker, TValue> {
114    fn borrow_mut(&mut self) -> &mut IdSlice<TMarker, TValue> {
115        IdSlice::from_mut_slice(self.as_mut_vec().borrow_mut())
116    }
117}
118
119impl<TMarker: ?Sized, TValue: Clone> Clone for IdVec<TMarker, TValue> {
120    fn clone(&self) -> Self {
121        Self::from_vec(self.as_vec().clone())
122    }
123}
124
125impl<TMarker: ?Sized, TValue: Debug> Debug for IdVec<TMarker, TValue> {
126    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
127        self.as_id_slice().fmt(f)
128    }
129}
130
131impl<TMarker: ?Sized, TValue> Default for IdVec<TMarker, TValue> {
132    fn default() -> Self {
133        Self::from_vec(Default::default())
134    }
135}
136
137impl<TMarker: ?Sized, TValue> Deref for IdVec<TMarker, TValue> {
138    type Target = IdSlice<TMarker, TValue>;
139
140    fn deref(&self) -> &Self::Target {
141        IdSlice::from_slice(self.as_vec().deref())
142    }
143}
144
145impl<TMarker: ?Sized, TValue> DerefMut for IdVec<TMarker, TValue> {
146    fn deref_mut(&mut self) -> &mut Self::Target {
147        IdSlice::from_mut_slice(self.as_mut_vec().deref_mut())
148    }
149}
150
151impl<TMarker: ?Sized, TValue> Eq for IdVec<TMarker, TValue> where TValue: PartialEq {}
152
153impl<'a, TMarker: ?Sized, TValue> Extend<&'a TValue> for IdVec<TMarker, TValue>
154where
155    TValue: Copy + 'a,
156{
157    fn extend<T: IntoIterator<Item = &'a TValue>>(&mut self, iter: T) {
158        self.as_mut_vec().extend(iter)
159    }
160}
161
162impl<TMarker: ?Sized, TValue> Extend<TValue> for IdVec<TMarker, TValue> {
163    fn extend<T: IntoIterator<Item = TValue>>(&mut self, iter: T) {
164        self.as_mut_vec().extend(iter)
165    }
166}
167
168impl<TMarker: ?Sized, TValue> From<Vec<TValue>> for IdVec<TMarker, TValue> {
169    fn from(value: Vec<TValue>) -> Self {
170        Self::from_vec(value)
171    }
172}
173
174impl<TMarker: ?Sized, TValue> FromIterator<TValue> for IdVec<TMarker, TValue> {
175    fn from_iter<T: IntoIterator<Item = TValue>>(iter: T) -> Self {
176        Self::from_vec(Vec::from_iter(iter))
177    }
178}
179
180impl<TMarker: ?Sized, TValue> Hash for IdVec<TMarker, TValue>
181where
182    Vec<TValue>: Hash,
183{
184    fn hash<H: Hasher>(&self, state: &mut H) {
185        self.as_vec().hash(state)
186    }
187
188    fn hash_slice<H>(data: &[Self], state: &mut H)
189    where
190        H: Hasher,
191    {
192        let data = unsafe { transmute(data) };
193        <Vec<TValue>>::hash_slice(data, state)
194    }
195}
196
197impl<TMarker: ?Sized, TValue, I: IdSliceIndex<IdSlice<TMarker, TValue>>> Index<I>
198    for IdVec<TMarker, TValue>
199{
200    type Output = I::Output;
201
202    fn index(&self, index: I) -> &Self::Output {
203        &self.as_id_slice()[index]
204    }
205}
206
207impl<TMarker: ?Sized, TValue, I: IdSliceIndex<IdSlice<TMarker, TValue>>> IndexMut<I>
208    for IdVec<TMarker, TValue>
209{
210    fn index_mut(&mut self, index: I) -> &mut Self::Output {
211        &mut self.as_mut_id_slice()[index]
212    }
213}
214
215impl<'a, TMarker: ?Sized, TValue> IntoIterator for &'a IdVec<TMarker, TValue> {
216    type Item = <&'a Vec<TValue> as IntoIterator>::Item;
217    type IntoIter = <&'a Vec<TValue> as IntoIterator>::IntoIter;
218
219    #[allow(clippy::into_iter_on_ref)]
220    fn into_iter(self) -> Self::IntoIter {
221        self.as_vec().into_iter()
222    }
223}
224
225impl<'a, TMarker: ?Sized, TValue> IntoIterator for &'a mut IdVec<TMarker, TValue> {
226    type Item = <&'a mut Vec<TValue> as IntoIterator>::Item;
227    type IntoIter = <&'a mut Vec<TValue> as IntoIterator>::IntoIter;
228
229    #[allow(clippy::into_iter_on_ref)]
230    fn into_iter(self) -> Self::IntoIter {
231        self.as_mut_vec().into_iter()
232    }
233}
234
235impl<TMarker: ?Sized, TValue> IntoIterator for IdVec<TMarker, TValue> {
236    type Item = <Vec<TValue> as IntoIterator>::Item;
237    type IntoIter = <Vec<TValue> as IntoIterator>::IntoIter;
238
239    fn into_iter(self) -> Self::IntoIter {
240        self.into_vec().into_iter()
241    }
242}
243
244impl<TMarker: ?Sized, TValue: Ord> Ord for IdVec<TMarker, TValue> {
245    fn cmp(&self, other: &Self) -> Ordering {
246        self.as_vec().cmp(other.as_vec())
247    }
248
249    fn max(self, other: Self) -> Self
250    where
251        Self: Sized,
252    {
253        Self::from_vec(self.into_vec().max(other.into_vec()))
254    }
255
256    fn min(self, other: Self) -> Self
257    where
258        Self: Sized,
259    {
260        Self::from_vec(self.into_vec().min(other.into_vec()))
261    }
262
263    fn clamp(self, min: Self, max: Self) -> Self
264    where
265        Self: Sized,
266        Self: PartialOrd,
267    {
268        Self::from_vec(self.into_vec().clamp(min.into_vec(), max.into_vec()))
269    }
270}
271
272impl<TMarker: ?Sized, TValueA, TValueB> PartialEq<&IdSlice<TMarker, TValueB>>
273    for IdVec<TMarker, TValueA>
274where
275    TValueA: PartialEq<TValueB>,
276{
277    fn eq(&self, other: &&IdSlice<TMarker, TValueB>) -> bool {
278        self.as_id_slice().eq(*other)
279    }
280
281    #[allow(clippy::partialeq_ne_impl)]
282    fn ne(&self, other: &&IdSlice<TMarker, TValueB>) -> bool {
283        self.as_id_slice().ne(*other)
284    }
285}
286
287impl<TMarker: ?Sized, TValueA, TValueB, const N: usize> PartialEq<&IdArray<TMarker, TValueB, N>>
288    for IdVec<TMarker, TValueA>
289where
290    TValueA: PartialEq<TValueB>,
291{
292    fn eq(&self, other: &&IdArray<TMarker, TValueB, N>) -> bool {
293        self.as_id_slice().eq(other.as_id_slice())
294    }
295
296    #[allow(clippy::partialeq_ne_impl)]
297    fn ne(&self, other: &&IdArray<TMarker, TValueB, N>) -> bool {
298        self.as_id_slice().ne(other.as_id_slice())
299    }
300}
301
302impl<TMarker: ?Sized, TValueA, TValueB> PartialEq<&mut IdSlice<TMarker, TValueB>>
303    for IdVec<TMarker, TValueA>
304where
305    TValueA: PartialEq<TValueB>,
306{
307    fn eq(&self, other: &&mut IdSlice<TMarker, TValueB>) -> bool {
308        self.as_id_slice().eq(*other)
309    }
310
311    #[allow(clippy::partialeq_ne_impl)]
312    fn ne(&self, other: &&mut IdSlice<TMarker, TValueB>) -> bool {
313        self.as_id_slice().ne(*other)
314    }
315}
316
317impl<TMarker: ?Sized, TValueA, TValueB> PartialEq<IdSlice<TMarker, TValueB>>
318    for IdVec<TMarker, TValueA>
319where
320    TValueA: PartialEq<TValueB>,
321{
322    fn eq(&self, other: &IdSlice<TMarker, TValueB>) -> bool {
323        self.as_id_slice().eq(other)
324    }
325
326    #[allow(clippy::partialeq_ne_impl)]
327    fn ne(&self, other: &IdSlice<TMarker, TValueB>) -> bool {
328        self.as_id_slice().ne(other)
329    }
330}
331
332impl<TMarker: ?Sized, TValueA, TValueB, const N: usize> PartialEq<IdArray<TMarker, TValueB, N>>
333    for IdVec<TMarker, TValueA>
334where
335    TValueA: PartialEq<TValueB>,
336{
337    fn eq(&self, other: &IdArray<TMarker, TValueB, N>) -> bool {
338        self.as_id_slice().eq(other.as_id_slice())
339    }
340
341    #[allow(clippy::partialeq_ne_impl)]
342    fn ne(&self, other: &IdArray<TMarker, TValueB, N>) -> bool {
343        self.as_id_slice().ne(other.as_id_slice())
344    }
345}
346
347impl<TMarker: ?Sized, TValueA, TValueB> PartialEq<IdVec<TMarker, TValueB>>
348    for IdVec<TMarker, TValueA>
349where
350    TValueA: PartialEq<TValueB>,
351{
352    fn eq(&self, other: &IdVec<TMarker, TValueB>) -> bool {
353        self.as_vec().eq(other.as_vec())
354    }
355
356    #[allow(clippy::partialeq_ne_impl)]
357    fn ne(&self, other: &IdVec<TMarker, TValueB>) -> bool {
358        self.as_vec().ne(other.as_vec())
359    }
360}
361
362#[allow(clippy::non_canonical_partial_ord_impl)]
363impl<TMarker: ?Sized, TValue: PartialOrd> PartialOrd for IdVec<TMarker, TValue> {
364    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
365        self.as_vec().partial_cmp(other.as_vec())
366    }
367
368    fn lt(&self, other: &Self) -> bool {
369        self.as_vec().lt(other.as_vec())
370    }
371
372    fn le(&self, other: &Self) -> bool {
373        self.as_vec().le(other.as_vec())
374    }
375
376    fn gt(&self, other: &Self) -> bool {
377        self.as_vec().gt(other.as_vec())
378    }
379
380    fn ge(&self, other: &Self) -> bool {
381        self.as_vec().ge(other.as_vec())
382    }
383}
id_sys/id_vec.rs

id_sys/
id_vec.rs
