orx_fixed_vec/
pinned_vec.rs

1use crate::FixedVec;
2use crate::helpers::range::{range_end, range_start};
3use core::cmp::Ordering;
4use core::iter::Rev;
5use core::ops::RangeBounds;
6use orx_iterable::Collection;
7use orx_pinned_vec::utils::slice;
8use orx_pinned_vec::{CapacityState, PinnedVec};
9use orx_pseudo_default::PseudoDefault;
10
11impl<T> PseudoDefault for FixedVec<T> {
12    fn pseudo_default() -> Self {
13        Self {
14            data: Default::default(),
15        }
16    }
17}
18
19impl<T> PinnedVec<T> for FixedVec<T> {
20    type IterRev<'a>
21        = Rev<core::slice::Iter<'a, T>>
22    where
23        T: 'a,
24        Self: 'a;
25
26    type IterMutRev<'a>
27        = Rev<core::slice::IterMut<'a, T>>
28    where
29        T: 'a,
30        Self: 'a;
31
32    type SliceIter<'a>
33        = Option<&'a [T]>
34    where
35        T: 'a,
36        Self: 'a;
37
38    type SliceMutIter<'a>
39        = Option<&'a mut [T]>
40    where
41        T: 'a,
42        Self: 'a;
43
44    /// Returns the index of the `element` with the given reference.
45    /// This method has *O(1)* time complexity.
46    ///
47    /// Note that `T: Eq` is not required; reference equality is used.
48    ///
49    /// # Safety
50    ///
51    /// Since `FixedVec` implements `PinnedVec`, the underlying memory
52    /// of the vector stays pinned; i.e., is not carried to different memory
53    /// locations.
54    /// Therefore, it is possible and safe to compare an element's reference
55    /// to find its position in the vector.
56    ///
57    /// # Examples
58    ///
59    /// ```
60    /// use orx_fixed_vec::prelude::*;
61    ///
62    /// let mut vec = FixedVec::new(4);
63    /// for i in 0..4 {
64    ///     vec.push(10 * i);
65    /// }
66    ///
67    /// assert_eq!(Some(0), vec.index_of(&vec[0]));
68    /// assert_eq!(Some(1), vec.index_of(&vec[1]));
69    /// assert_eq!(Some(2), vec.index_of(&vec[2]));
70    /// assert_eq!(Some(3), vec.index_of(&vec[3]));
71    ///
72    /// // num certainly does not belong to `vec`
73    /// let num = 42;
74    /// assert_eq!(None, vec.index_of(&num));
75    ///
76    /// // even if its value belongs
77    /// let num = 20;
78    /// assert_eq!(None, vec.index_of(&num));
79    ///
80    /// // as expected, querying elements of another vector will also fail
81    /// let eq_vec = vec![0, 10, 20, 30];
82    /// for i in 0..4 {
83    ///     assert_eq!(None, vec.index_of(&eq_vec[i]));
84    /// }
85    /// ```
86    #[inline(always)]
87    fn index_of(&self, element: &T) -> Option<usize> {
88        slice::index_of(&self.data, element)
89    }
90
91    fn index_of_ptr(&self, element_ptr: *const T) -> Option<usize> {
92        slice::index_of_ptr(&self.data, element_ptr)
93    }
94
95    fn push_get_ptr(&mut self, value: T) -> *const T {
96        let idx = self.data.len();
97        self.data.push(value);
98        unsafe { self.data.as_ptr().add(idx) }
99    }
100
101    unsafe fn iter_ptr<'v, 'i>(&'v self) -> impl Iterator<Item = *const T> + 'i
102    where
103        T: 'i,
104    {
105        let ptr = self.data.as_ptr();
106        (0..self.data.len()).map(move |i| unsafe { ptr.add(i) })
107    }
108
109    unsafe fn iter_ptr_rev<'v, 'i>(&'v self) -> impl Iterator<Item = *const T> + 'i
110    where
111        T: 'i,
112    {
113        let ptr = self.data.as_ptr();
114        (0..self.data.len())
115            .rev()
116            .map(move |i| unsafe { ptr.add(i) })
117    }
118
119    /// Returns whether or not the `element` with the given reference belongs to the vector.
120    /// This method has *O(1)* time complexity.
121    ///
122    /// Note that `T: Eq` is not required; memory address is used.
123    ///
124    /// # Safety
125    ///
126    /// Since `FixedVec` implements `PinnedVec`, the underlying memory
127    /// of the vector stays pinned; i.e., is not carried to different memory
128    /// locations.
129    /// Therefore, it is possible and safe to compare an element's reference
130    /// to find its position in the vector.
131    ///
132    /// # Examples
133    ///
134    /// ```
135    /// use orx_fixed_vec::prelude::*;
136    ///
137    /// let mut vec = FixedVec::new(4);
138    /// for i in 0..4 {
139    ///     vec.push(10 * i);
140    /// }
141    ///
142    /// assert!(vec.contains_reference(&vec[0]));
143    /// assert!(vec.contains_reference(&vec[1]));
144    /// assert!(vec.contains_reference(&vec[2]));
145    /// assert!(vec.contains_reference(&vec[3]));
146    ///
147    /// // num certainly does not belong to `vec`
148    /// let num = 42;
149    /// assert!(!vec.contains_reference(&num));
150    ///
151    /// // even if its value belongs
152    /// let num = 20;
153    /// assert!(!vec.contains_reference(&num));
154    ///
155    /// // as expected, querying elements of another vector will also fail
156    /// let eq_vec = vec![0, 10, 20, 30];
157    /// for i in 0..4 {
158    ///     assert!(!vec.contains_reference(&eq_vec[i]));
159    /// }
160    /// ```
161    #[inline(always)]
162    fn contains_reference(&self, element: &T) -> bool {
163        slice::contains_reference(self.data.as_slice(), element)
164    }
165
166    /// Returns whether or not the `element` with the given reference belongs to the vector.
167    /// This method has *O(1)* time complexity.
168    ///
169    /// Note that `T: Eq` is not required; memory pointer is used.
170    ///
171    /// # Safety
172    ///
173    /// Since `FixedVec` implements `PinnedVec`, the underlying memory
174    /// of the vector stays pinned; i.e., is not carried to different memory
175    /// locations.
176    /// Therefore, it is possible and safe to compare an element's reference
177    /// to find its position in the vector.
178    #[inline(always)]
179    fn contains_ptr(&self, element_ptr: *const T) -> bool {
180        slice::contains_ptr(self.data.as_slice(), element_ptr)
181    }
182
183    fn clear(&mut self) {
184        self.data.clear();
185    }
186
187    fn capacity(&self) -> usize {
188        self.data.capacity()
189    }
190
191    fn capacity_state(&self) -> CapacityState {
192        CapacityState::FixedCapacity(self.capacity())
193    }
194
195    /// Clones and appends all elements in a slice to the Vec.
196    ///
197    /// Iterates over the slice other, clones each element, and then appends it to this Vec. The other slice is traversed in-order.
198    ///
199    /// Note that this function is same as extend except that it is specialized to work with slices instead. If and when Rust gets specialization this function will likely be deprecated (but still available).
200    ///
201    /// # Panics
202    ///
203    /// Panics if there is not enough room in the vector for the elements in `other`;
204    /// i.e., `self.room() < other.len()`.
205    fn extend_from_slice(&mut self, other: &[T])
206    where
207        T: Clone,
208    {
209        self.panic_if_not_enough_room_for(other.len());
210        self.data.extend_from_slice(other);
211    }
212
213    #[inline(always)]
214    fn get(&self, index: usize) -> Option<&T> {
215        self.data.get(index)
216    }
217
218    #[inline(always)]
219    fn get_mut(&mut self, index: usize) -> Option<&mut T> {
220        self.data.get_mut(index)
221    }
222
223    #[inline(always)]
224    unsafe fn get_unchecked(&self, index: usize) -> &T {
225        unsafe { self.data.get_unchecked(index) }
226    }
227
228    #[inline(always)]
229    unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {
230        unsafe { self.data.get_unchecked_mut(index) }
231    }
232
233    #[inline(always)]
234    fn first(&self) -> Option<&T> {
235        self.data.first()
236    }
237
238    #[inline(always)]
239    fn last(&self) -> Option<&T> {
240        self.data.last()
241    }
242
243    #[inline(always)]
244    unsafe fn first_unchecked(&self) -> &T {
245        unsafe { self.data.get_unchecked(0) }
246    }
247
248    #[inline(always)]
249    unsafe fn last_unchecked(&self) -> &T {
250        unsafe { self.data.get_unchecked(self.data.len() - 1) }
251    }
252
253    #[inline(always)]
254    fn is_empty(&self) -> bool {
255        self.data.is_empty()
256    }
257
258    #[inline(always)]
259    fn len(&self) -> usize {
260        self.data.len()
261    }
262
263    /// Appends an element to the back of a collection.
264    ///
265    /// # Panics
266    ///
267    /// Panics if there is no available room in the vector;
268    /// i.e., `self.is_full()` or equivalently `self.len() == self.capacity()`.
269    #[inline(always)]
270    fn push(&mut self, value: T) {
271        self.push_or_panic(value)
272    }
273
274    /// Inserts an element at position index within the vector, shifting all elements after it to the right.
275    ///
276    /// # Panics
277    /// Panics if `index >= len`.
278    ///
279    /// Panics also if there is no available room in the vector;
280    /// i.e., `self.is_full()` or equivalently `self.len() == self.capacity()`.
281    #[inline(always)]
282    fn insert(&mut self, index: usize, element: T) {
283        self.panic_if_not_enough_room_for(1);
284        self.data.insert(index, element)
285    }
286
287    #[inline(always)]
288    fn remove(&mut self, index: usize) -> T {
289        self.data.remove(index)
290    }
291
292    #[inline(always)]
293    fn pop(&mut self) -> Option<T> {
294        self.data.pop()
295    }
296
297    #[inline(always)]
298    fn swap(&mut self, a: usize, b: usize) {
299        self.data.swap(a, b)
300    }
301
302    #[inline(always)]
303    fn truncate(&mut self, len: usize) {
304        self.data.truncate(len)
305    }
306
307    #[inline(always)]
308    fn iter_rev(&self) -> Self::IterRev<'_> {
309        self.data.iter().rev()
310    }
311
312    #[inline(always)]
313    fn iter_mut_rev(&mut self) -> Self::IterMutRev<'_> {
314        self.data.iter_mut().rev()
315    }
316
317    /// Returns the view on the required `range` as an Option of slice:
318    ///
319    /// * returns None if the range is out of bounds;
320    /// * returns Some of the slice when the range is within bounds of the fixed vector.
321    ///
322    /// # Examples
323    ///
324    /// ```
325    /// use orx_fixed_vec::prelude::*;
326    ///
327    /// let mut vec = FixedVec::new(10);
328    ///
329    /// vec.extend_from_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
330    ///
331    /// assert_eq!(vec.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
332    ///
333    /// // within bounds
334    /// assert_eq!(vec.slices(0..4).unwrap(), &[0, 1, 2, 3]);
335    /// assert_eq!(vec.slices(5..7).unwrap(), &[5, 6]);
336    /// assert_eq!(vec.slices(8..10).unwrap(), &[8, 9]);
337    ///
338    /// // OutOfBounds
339    /// assert!(vec.slices(5..12).is_none());
340    /// assert!(vec.slices(10..11).is_none());
341    /// ```
342    fn slices<R: RangeBounds<usize>>(&self, range: R) -> Self::SliceIter<'_> {
343        let a = range_start(&range);
344        let b = range_end(&range, self.len());
345
346        match b.saturating_sub(a) {
347            0 => Some(&[]),
348            _ => match (a.cmp(&self.len()), b.cmp(&self.len())) {
349                (Ordering::Equal | Ordering::Greater, _) => None,
350                (_, Ordering::Greater) => None,
351                _ => Some(&self.data[a..b]),
352            },
353        }
354    }
355
356    /// Returns a mutable view on the required `range` as an Option of slice:
357    ///
358    /// * returns None if the range is out of bounds;
359    /// * returns Some of the slice when the range is within bounds of the fixed vector.
360    ///
361    /// # Examples
362    ///
363    /// ```
364    /// use orx_fixed_vec::prelude::*;
365    ///
366    /// let mut vec = FixedVec::new(10);
367    ///
368    /// vec.extend_from_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
369    ///
370    /// assert_eq!(vec.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
371    ///
372    /// // within bounds
373    /// let mut slice = vec.slices_mut(0..4).unwrap();
374    /// assert_eq!(slice, &[0, 1, 2, 3]);
375    /// slice[1] *= 10;
376    /// assert_eq!(vec.as_slice(), &[0, 10, 2, 3, 4, 5, 6, 7, 8, 9]);
377    ///
378    ///
379    /// let mut slice = vec.slices_mut(5..7).unwrap();
380    /// assert_eq!(slice, &[5, 6]);
381    /// slice[0] *= 10;
382    /// assert_eq!(vec.as_slice(), &[0, 10, 2, 3, 4, 50, 6, 7, 8, 9]);
383    ///
384    /// // OutOfBounds
385    /// assert!(vec.slices_mut(5..12).is_none());
386    /// assert!(vec.slices_mut(10..11).is_none());
387    /// ```
388    #[inline(always)]
389    fn slices_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Self::SliceMutIter<'_> {
390        let a = range_start(&range);
391        let b = range_end(&range, self.len());
392
393        match b.saturating_sub(a) {
394            0 => Some(&mut []),
395            _ => match (a.cmp(&self.len()), b.cmp(&self.len())) {
396                (Ordering::Equal | Ordering::Greater, _) => None,
397                (_, Ordering::Greater) => None,
398                _ => Some(&mut self.data[a..b]),
399            },
400        }
401    }
402
403    fn iter_over<'a>(
404        &'a self,
405        range: impl RangeBounds<usize>,
406    ) -> impl ExactSizeIterator<Item = &'a T>
407    where
408        T: 'a,
409    {
410        use core::cmp::{max, min};
411
412        let len = PinnedVec::len(self);
413        let a = min(len, range_start(&range));
414        let b = max(a, min(len, range_end(&range, len)));
415
416        self.data[a..b].iter()
417    }
418
419    fn iter_mut_over<'a>(
420        &'a mut self,
421        range: impl RangeBounds<usize>,
422    ) -> impl ExactSizeIterator<Item = &'a mut T>
423    where
424        T: 'a,
425    {
426        use core::cmp::{max, min};
427
428        let len = PinnedVec::len(self);
429        let a = min(len, range_start(&range));
430        let b = max(a, min(len, range_end(&range, len)));
431
432        self.data[a..b].iter_mut()
433    }
434
435    #[inline(always)]
436    fn get_ptr(&self, index: usize) -> Option<*const T> {
437        (index < self.data.capacity()).then(|| unsafe { self.data.as_ptr().add(index) })
438    }
439
440    #[inline(always)]
441    fn get_ptr_mut(&mut self, index: usize) -> Option<*mut T> {
442        (index < self.data.capacity()).then(|| unsafe { self.data.as_mut_ptr().add(index) })
443    }
444
445    #[inline(always)]
446    unsafe fn set_len(&mut self, new_len: usize) {
447        unsafe { self.data.set_len(new_len) }
448    }
449
450    fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>
451    where
452        F: FnMut(&T) -> Ordering,
453    {
454        self.data.binary_search_by(f)
455    }
456
457    fn sort(&mut self)
458    where
459        T: Ord,
460    {
461        self.data.sort();
462    }
463
464    fn sort_by<F>(&mut self, compare: F)
465    where
466        F: FnMut(&T, &T) -> Ordering,
467    {
468        self.data.sort_by(compare)
469    }
470
471    fn sort_by_key<K, F>(&mut self, f: F)
472    where
473        F: FnMut(&T) -> K,
474        K: Ord,
475    {
476        self.data.sort_by_key(f)
477    }
478
479    fn capacity_bound(&self) -> usize {
480        usize::MAX
481    }
482}
483
484#[cfg(test)]
485mod tests {
486    use crate::prelude::*;
487    use alloc::string::String;
488    use alloc::vec::Vec;
489    use orx_pinned_vec::*;
490    use orx_pseudo_default::PseudoDefault;
491
492    #[test]
493    fn pinned_vec_exact_capacity() {
494        #[cfg(not(miri))]
495        let capacities = [0, 124, 5421];
496        #[cfg(miri)]
497        let capacities = [0, 44];
498
499        for cap in capacities {
500            test_pinned_vec(FixedVec::new(cap), cap);
501        }
502    }
503
504    #[test]
505    fn pinned_vec_loose_capacity() {
506        #[cfg(not(miri))]
507        let capacities = [0, 124, 5421];
508        #[cfg(miri)]
509        let capacities = [0, 44];
510
511        for cap in capacities {
512            test_pinned_vec(FixedVec::new(cap * 2), cap);
513        }
514    }
515
516    #[test]
517    fn into_inner() {
518        let fixed: FixedVec<_> = (0..16).collect();
519        let vec = fixed.into_inner();
520        assert_eq!(vec, (0..16).collect::<Vec<_>>())
521    }
522
523    #[test]
524    fn index_of_and_contains() {
525        fn test(mut vec: FixedVec<usize>) {
526            let mut another_vec = Vec::new();
527            for i in 0..42 {
528                vec.push(i);
529                another_vec.push(i);
530            }
531            for i in 0..vec.len() {
532                assert_eq!(Some(i), vec.index_of(&vec[i]));
533                assert!(vec.contains_reference(&vec[i]));
534
535                assert_eq!(None, vec.index_of(&another_vec[i]));
536                assert!(!vec.contains_reference(&another_vec[i]));
537
538                let scalar = another_vec[i];
539                assert_eq!(None, vec.index_of(&scalar));
540                assert!(!vec.contains_reference(&scalar));
541            }
542        }
543        test(FixedVec::new(42));
544        test(FixedVec::new(1000));
545    }
546
547    #[test]
548    fn len_and_is_empty() {
549        fn test_len(mut vec: FixedVec<usize>) {
550            for i in 0..42 {
551                assert_eq!(i, vec.len());
552                vec.push(i);
553            }
554            assert_eq!(42, vec.len());
555
556            vec.clear();
557            assert_eq!(0, vec.len());
558
559            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
560            assert_eq!(42, vec.len());
561
562            for i in 0..42 {
563                assert_eq!(42 - i, vec.len());
564                vec.pop();
565            }
566            assert_eq!(0, vec.len());
567
568            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
569            for i in 0..42 {
570                assert_eq!(42 - i, vec.len());
571                vec.remove(vec.len() / 2);
572            }
573            assert_eq!(0, vec.len());
574
575            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
576            for i in 0..42 {
577                assert_eq!(42 - i, vec.len());
578                vec.remove(0);
579            }
580            assert_eq!(0, vec.len());
581
582            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
583            for i in 0..42 {
584                assert_eq!(42 - i, vec.len());
585                vec.remove(vec.len() - 1);
586            }
587            assert_eq!(0, vec.len());
588
589            vec.clear();
590            for i in 0..42 {
591                assert_eq!(i, vec.len());
592                vec.insert(i, i);
593            }
594            assert_eq!(42, vec.len());
595
596            vec.clear();
597            for i in 0..42 {
598                assert_eq!(i, vec.len());
599                vec.insert(0, i);
600            }
601            assert_eq!(42, vec.len());
602        }
603
604        test_len(FixedVec::new(42));
605        test_len(FixedVec::new(1_000));
606    }
607
608    #[test]
609    fn capacity() {
610        let vec: FixedVec<char> = FixedVec::new(44);
611        assert_eq!(44, vec.capacity());
612        assert_eq!(CapacityState::FixedCapacity(44), vec.capacity_state());
613    }
614
615    #[test]
616    fn clear() {
617        fn clear_is_empty(mut vec: FixedVec<usize>) {
618            vec.clear();
619            assert!(vec.is_empty());
620            assert_eq!(0, vec.len());
621
622            vec.push(1);
623            assert!(!vec.is_empty());
624            for i in 0..42 {
625                vec.push(i);
626            }
627            assert!(!vec.is_empty());
628
629            vec.clear();
630            assert!(vec.is_empty());
631            assert_eq!(0, vec.len());
632        }
633        clear_is_empty(FixedVec::new(43));
634        clear_is_empty(FixedVec::new(1000));
635    }
636
637    #[test]
638    fn get() {
639        fn test_get(mut vec: FixedVec<usize>) {
640            assert!(vec.is_empty());
641
642            for i in 0..53 {
643                vec.push(i);
644
645                assert_eq!(vec.get(i), Some(&i));
646                assert_eq!(vec.get(i + 1), None);
647
648                *vec.get_mut(i).expect("is-some") += 100;
649                *unsafe { vec.get_unchecked_mut(i) } += 10;
650            }
651
652            for i in 0..53 {
653                assert_eq!(vec.get(i), Some(&(110 + i)));
654                assert_eq!(unsafe { vec.get_unchecked(i) }, &(110 + i));
655            }
656        }
657        test_get(FixedVec::new(53));
658        test_get(FixedVec::new(1000));
659    }
660
661    #[test]
662    fn first_last() {
663        let mut vec = FixedVec::new(6);
664
665        assert!(vec.first().is_none());
666        assert!(vec.last().is_none());
667
668        vec.push(42);
669
670        assert_eq!(vec.first(), Some(&42));
671        assert_eq!(vec.last(), Some(&42));
672
673        unsafe {
674            assert_eq!(vec.first_unchecked(), &42);
675            assert_eq!(vec.last_unchecked(), &42);
676        }
677
678        vec.push(7);
679
680        assert_eq!(vec.first(), Some(&42));
681        assert_eq!(vec.last(), Some(&7));
682
683        unsafe {
684            assert_eq!(vec.first_unchecked(), &42);
685            assert_eq!(vec.last_unchecked(), &7);
686        }
687
688        vec.insert(1, 56421);
689
690        assert_eq!(vec.first(), Some(&42));
691        assert_eq!(vec.last(), Some(&7));
692
693        unsafe {
694            assert_eq!(vec.first_unchecked(), &42);
695            assert_eq!(vec.last_unchecked(), &7);
696        }
697
698        vec.clear();
699
700        assert!(vec.first().is_none());
701        assert!(vec.last().is_none());
702    }
703
704    #[test]
705    fn extend_from_slice() {
706        fn test(mut vec: FixedVec<usize>) {
707            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
708            vec.extend_from_slice(&(42..63).collect::<Vec<_>>());
709            vec.extend_from_slice(&(63..100).collect::<Vec<_>>());
710
711            assert_eq!(100, vec.len());
712            for i in 0..100 {
713                assert_eq!(Some(&i), vec.get(i));
714            }
715        }
716        test(FixedVec::new(100));
717        test(FixedVec::new(1000));
718    }
719
720    #[test]
721    fn grow() {
722        fn test(mut vec: FixedVec<usize>) {
723            for i in 0..42 {
724                vec.push(i);
725            }
726            for i in 0..42 {
727                vec.insert(i, 100 + i);
728            }
729
730            for i in 0..42 {
731                assert_eq!(Some(&i), vec.get(42 + i));
732                assert_eq!(Some(&(100 + i)), vec.get(i));
733            }
734        }
735        test(FixedVec::new(84));
736        test(FixedVec::new(1000));
737    }
738
739    #[test]
740    fn shrink() {
741        fn test(mut vec: FixedVec<usize>) {
742            for i in 0..42 {
743                vec.push(i);
744                assert_eq!(i, vec.remove(0));
745                assert!(vec.is_empty());
746            }
747
748            for i in 0..42 {
749                vec.push(i);
750            }
751            for i in 0..42 {
752                assert_eq!(i, vec.remove(0));
753            }
754            assert!(vec.is_empty());
755
756            for i in 0..42 {
757                vec.push(i);
758            }
759            for i in (0..42).rev() {
760                assert_eq!(Some(i), vec.pop());
761            }
762            assert_eq!(None, vec.pop());
763            assert!(vec.is_empty());
764
765            for i in 0..42 {
766                vec.push(i);
767            }
768            for _ in 0..42 {
769                vec.remove(vec.len() / 2);
770            }
771            assert!(vec.is_empty());
772        }
773        test(FixedVec::new(42));
774        test(FixedVec::new(1000));
775    }
776
777    #[test]
778    fn swap() {
779        fn test(mut vec: FixedVec<usize>) {
780            for i in 0..42 {
781                vec.push(i);
782            }
783
784            for i in 0..21 {
785                vec.swap(i, 21 + i);
786            }
787
788            for i in 0..21 {
789                assert_eq!(21 + i, vec[i]);
790            }
791            for i in 21..42 {
792                assert_eq!(i - 21, vec[i]);
793            }
794        }
795        test(FixedVec::new(42));
796        test(FixedVec::new(1000));
797    }
798    #[test]
799    fn truncate() {
800        fn test(mut vec: FixedVec<usize>) {
801            for i in 0..42 {
802                vec.push(i);
803            }
804
805            vec.truncate(100);
806            assert_eq!(vec, (0..42).collect::<Vec<_>>());
807
808            vec.truncate(21);
809            assert_eq!(vec, (0..21).collect::<Vec<_>>());
810        }
811        test(FixedVec::new(42));
812        test(FixedVec::new(1000));
813    }
814
815    #[test]
816    fn eq() {
817        fn test(mut vec: FixedVec<usize>) {
818            let slice = &(0..42).collect::<Vec<usize>>();
819            for i in 0..42 {
820                vec.push(i);
821            }
822            assert!(vec.eq(slice));
823
824            vec.remove(7);
825            assert!(!vec.eq(slice));
826        }
827
828        test(FixedVec::new(142));
829        test(FixedVec::new(1000));
830    }
831
832    #[test]
833    fn clone() {
834        fn test(mut vec: FixedVec<usize>) {
835            assert!(vec.is_empty());
836
837            for i in 0..53 {
838                vec.push(i);
839            }
840
841            let clone = vec.clone();
842            assert_eq!(vec, clone);
843        }
844
845        test(FixedVec::new(53));
846        test(FixedVec::new(1000));
847    }
848
849    #[test]
850    fn slices() {
851        #![allow(for_loops_over_fallibles)]
852        let mut vec = FixedVec::new(184);
853
854        for i in 0..184 {
855            assert!(vec.slices(i..i + 1).is_none());
856            assert!(vec.slices(0..i + 1).is_none());
857            vec.push(i);
858        }
859
860        let slice = vec.slices(0..vec.len());
861        let mut combined = Vec::new();
862        for s in slice {
863            combined.extend_from_slice(s);
864        }
865        for i in 0..184 {
866            assert_eq!(i, vec[i]);
867            assert_eq!(i, combined[i]);
868        }
869
870        let begin = vec.len() / 4;
871        let end = 3 * vec.len() / 4;
872        let slice = vec.slices(begin..end);
873        let mut combined = Vec::new();
874        for s in slice {
875            combined.extend_from_slice(s);
876        }
877        for i in begin..end {
878            assert_eq!(i, vec[i]);
879            assert_eq!(i, combined[i - begin]);
880        }
881    }
882
883    #[test]
884    fn slices_mut() {
885        #![allow(for_loops_over_fallibles)]
886        let mut vec = FixedVec::new(184);
887
888        for i in 0..184 {
889            assert!(vec.slices_mut(i..i + 1).is_none());
890            assert!(vec.slices_mut(0..i + 1).is_none());
891            vec.push(i);
892        }
893
894        let slice = vec.slices_mut(0..vec.len());
895        let mut combined = Vec::new();
896        for s in slice {
897            combined.extend_from_slice(s);
898        }
899        for i in 0..184 {
900            assert_eq!(i, vec[i]);
901            assert_eq!(i, combined[i]);
902        }
903
904        let begin = vec.len() / 4;
905        let end = 3 * vec.len() / 4;
906        let slice = vec.slices_mut(begin..end);
907        let mut combined = Vec::new();
908        for s in slice {
909            combined.extend_from_slice(s);
910        }
911        for i in begin..end {
912            assert_eq!(i, vec[i]);
913            assert_eq!(i, combined[i - begin]);
914        }
915
916        vec.clear();
917
918        for _ in 0..184 {
919            vec.push(0);
920        }
921
922        fn update(slice: Option<&mut [usize]>, begin: usize) {
923            let mut val = begin;
924            for s in slice {
925                for x in s {
926                    *x = val;
927                    val += 1;
928                }
929            }
930        }
931        let mut fill = |begin: usize, end: usize| {
932            let range = begin..end;
933            update(vec.slices_mut(range), begin);
934        };
935
936        fill(0, 14);
937        fill(14, 56);
938        fill(56, 77);
939        fill(77, 149);
940        fill(149, 182);
941        fill(182, 184);
942        for i in 0..184 {
943            assert_eq!(vec.get(i), Some(&i));
944        }
945    }
946
947    #[test]
948    fn iter_iter_mut() {
949        let mut vec = FixedVec::new(4);
950        vec.push('a');
951        vec.push('b');
952
953        let mut iter = vec.iter();
954        assert_eq!(Some(&'a'), iter.next());
955        assert_eq!(Some(&'b'), iter.next());
956        assert_eq!(None, iter.next());
957
958        for x in vec.iter_mut() {
959            *x = 'x';
960        }
961
962        let mut iter = vec.iter();
963        assert_eq!(Some(&'x'), iter.next());
964        assert_eq!(Some(&'x'), iter.next());
965        assert_eq!(None, iter.next());
966    }
967
968    #[test]
969    fn rev_iter_iter_mut() {
970        let mut vec = FixedVec::new(4);
971        vec.push('a');
972        vec.push('b');
973
974        let mut iter = vec.iter_rev();
975        assert_eq!(Some(&'b'), iter.next());
976        assert_eq!(Some(&'a'), iter.next());
977        assert_eq!(None, iter.next());
978
979        for x in vec.iter_mut_rev() {
980            *x = 'x';
981        }
982
983        let mut iter = vec.iter_rev();
984        assert_eq!(Some(&'x'), iter.next());
985        assert_eq!(Some(&'x'), iter.next());
986        assert_eq!(None, iter.next());
987    }
988
989    #[derive(Debug, PartialEq, Clone)]
990    struct Num(usize);
991    #[test]
992    fn insert() {
993        fn test(mut vec: FixedVec<Num>) {
994            for i in 0..42 {
995                vec.push(Num(i));
996            }
997            for i in 0..42 {
998                vec.insert(i, Num(100 + i));
999            }
1000
1001            for i in 0..42 {
1002                assert_eq!(Some(&Num(i)), vec.get(42 + i));
1003                assert_eq!(Some(&Num(100 + i)), vec.get(i));
1004            }
1005        }
1006        test(FixedVec::new(84));
1007        test(FixedVec::new(1000));
1008    }
1009
1010    #[test]
1011    fn pseudo_default() {
1012        let vec = FixedVec::<String>::pseudo_default();
1013        assert_eq!(0, vec.capacity());
1014        assert_eq!(0, vec.len());
1015    }
1016}
orx_fixed_vec/pinned_vec.rs

orx_fixed_vec/
pinned_vec.rs
