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    unsafe fn extend_from_nonoverlapping(&mut self, src: *const T, count: usize) {
214        self.data.reserve(count);
215        let dst = unsafe { self.data.as_mut_ptr().add(self.data.len()) };
216        unsafe { dst.copy_from_nonoverlapping(src, count) };
217        unsafe { self.data.set_len(self.data.len() + count) };
218    }
219
220    #[inline(always)]
221    fn get(&self, index: usize) -> Option<&T> {
222        self.data.get(index)
223    }
224
225    #[inline(always)]
226    fn get_mut(&mut self, index: usize) -> Option<&mut T> {
227        self.data.get_mut(index)
228    }
229
230    #[inline(always)]
231    unsafe fn get_unchecked(&self, index: usize) -> &T {
232        unsafe { self.data.get_unchecked(index) }
233    }
234
235    #[inline(always)]
236    unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {
237        unsafe { self.data.get_unchecked_mut(index) }
238    }
239
240    #[inline(always)]
241    fn first(&self) -> Option<&T> {
242        self.data.first()
243    }
244
245    #[inline(always)]
246    fn last(&self) -> Option<&T> {
247        self.data.last()
248    }
249
250    #[inline(always)]
251    unsafe fn first_unchecked(&self) -> &T {
252        unsafe { self.data.get_unchecked(0) }
253    }
254
255    #[inline(always)]
256    unsafe fn last_unchecked(&self) -> &T {
257        unsafe { self.data.get_unchecked(self.data.len() - 1) }
258    }
259
260    #[inline(always)]
261    fn is_empty(&self) -> bool {
262        self.data.is_empty()
263    }
264
265    #[inline(always)]
266    fn len(&self) -> usize {
267        self.data.len()
268    }
269
270    /// Appends an element to the back of a collection.
271    ///
272    /// # Panics
273    ///
274    /// Panics if there is no available room in the vector;
275    /// i.e., `self.is_full()` or equivalently `self.len() == self.capacity()`.
276    #[inline(always)]
277    fn push(&mut self, value: T) {
278        self.push_or_panic(value)
279    }
280
281    /// Inserts an element at position index within the vector, shifting all elements after it to the right.
282    ///
283    /// # Panics
284    /// Panics if `index >= len`.
285    ///
286    /// Panics also if there is no available room in the vector;
287    /// i.e., `self.is_full()` or equivalently `self.len() == self.capacity()`.
288    #[inline(always)]
289    fn insert(&mut self, index: usize, element: T) {
290        self.panic_if_not_enough_room_for(1);
291        self.data.insert(index, element)
292    }
293
294    #[inline(always)]
295    fn remove(&mut self, index: usize) -> T {
296        self.data.remove(index)
297    }
298
299    #[inline(always)]
300    fn pop(&mut self) -> Option<T> {
301        self.data.pop()
302    }
303
304    #[inline(always)]
305    fn swap(&mut self, a: usize, b: usize) {
306        self.data.swap(a, b)
307    }
308
309    #[inline(always)]
310    fn truncate(&mut self, len: usize) {
311        self.data.truncate(len)
312    }
313
314    #[inline(always)]
315    fn iter_rev(&self) -> Self::IterRev<'_> {
316        self.data.iter().rev()
317    }
318
319    #[inline(always)]
320    fn iter_mut_rev(&mut self) -> Self::IterMutRev<'_> {
321        self.data.iter_mut().rev()
322    }
323
324    /// Returns the view on the required `range` as an Option of slice:
325    ///
326    /// * returns None if the range is out of bounds;
327    /// * returns Some of the slice when the range is within bounds of the fixed vector.
328    ///
329    /// # Examples
330    ///
331    /// ```
332    /// use orx_fixed_vec::prelude::*;
333    ///
334    /// let mut vec = FixedVec::new(10);
335    ///
336    /// vec.extend_from_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
337    ///
338    /// assert_eq!(vec.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
339    ///
340    /// // within bounds
341    /// assert_eq!(vec.slices(0..4).unwrap(), &[0, 1, 2, 3]);
342    /// assert_eq!(vec.slices(5..7).unwrap(), &[5, 6]);
343    /// assert_eq!(vec.slices(8..10).unwrap(), &[8, 9]);
344    ///
345    /// // OutOfBounds
346    /// assert!(vec.slices(5..12).is_none());
347    /// assert!(vec.slices(10..11).is_none());
348    /// ```
349    fn slices<R: RangeBounds<usize>>(&self, range: R) -> Self::SliceIter<'_> {
350        let a = range_start(&range);
351        let b = range_end(&range, self.len());
352
353        match b.saturating_sub(a) {
354            0 => Some(&[]),
355            _ => match (a.cmp(&self.len()), b.cmp(&self.len())) {
356                (Ordering::Equal | Ordering::Greater, _) => None,
357                (_, Ordering::Greater) => None,
358                _ => Some(&self.data[a..b]),
359            },
360        }
361    }
362
363    /// Returns a mutable view on the required `range` as an Option of slice:
364    ///
365    /// * returns None if the range is out of bounds;
366    /// * returns Some of the slice when the range is within bounds of the fixed vector.
367    ///
368    /// # Examples
369    ///
370    /// ```
371    /// use orx_fixed_vec::prelude::*;
372    ///
373    /// let mut vec = FixedVec::new(10);
374    ///
375    /// vec.extend_from_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
376    ///
377    /// assert_eq!(vec.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
378    ///
379    /// // within bounds
380    /// let mut slice = vec.slices_mut(0..4).unwrap();
381    /// assert_eq!(slice, &[0, 1, 2, 3]);
382    /// slice[1] *= 10;
383    /// assert_eq!(vec.as_slice(), &[0, 10, 2, 3, 4, 5, 6, 7, 8, 9]);
384    ///
385    ///
386    /// let mut slice = vec.slices_mut(5..7).unwrap();
387    /// assert_eq!(slice, &[5, 6]);
388    /// slice[0] *= 10;
389    /// assert_eq!(vec.as_slice(), &[0, 10, 2, 3, 4, 50, 6, 7, 8, 9]);
390    ///
391    /// // OutOfBounds
392    /// assert!(vec.slices_mut(5..12).is_none());
393    /// assert!(vec.slices_mut(10..11).is_none());
394    /// ```
395    #[inline(always)]
396    fn slices_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Self::SliceMutIter<'_> {
397        let a = range_start(&range);
398        let b = range_end(&range, self.len());
399
400        match b.saturating_sub(a) {
401            0 => Some(&mut []),
402            _ => match (a.cmp(&self.len()), b.cmp(&self.len())) {
403                (Ordering::Equal | Ordering::Greater, _) => None,
404                (_, Ordering::Greater) => None,
405                _ => Some(&mut self.data[a..b]),
406            },
407        }
408    }
409
410    fn iter_over<'a>(
411        &'a self,
412        range: impl RangeBounds<usize>,
413    ) -> impl ExactSizeIterator<Item = &'a T>
414    where
415        T: 'a,
416    {
417        use core::cmp::{max, min};
418
419        let len = PinnedVec::len(self);
420        let a = min(len, range_start(&range));
421        let b = max(a, min(len, range_end(&range, len)));
422
423        self.data[a..b].iter()
424    }
425
426    fn iter_mut_over<'a>(
427        &'a mut self,
428        range: impl RangeBounds<usize>,
429    ) -> impl ExactSizeIterator<Item = &'a mut T>
430    where
431        T: 'a,
432    {
433        use core::cmp::{max, min};
434
435        let len = PinnedVec::len(self);
436        let a = min(len, range_start(&range));
437        let b = max(a, min(len, range_end(&range, len)));
438
439        self.data[a..b].iter_mut()
440    }
441
442    #[inline(always)]
443    fn get_ptr(&self, index: usize) -> Option<*const T> {
444        (index < self.data.capacity()).then(|| unsafe { self.data.as_ptr().add(index) })
445    }
446
447    #[inline(always)]
448    fn get_ptr_mut(&mut self, index: usize) -> Option<*mut T> {
449        (index < self.data.capacity()).then(|| unsafe { self.data.as_mut_ptr().add(index) })
450    }
451
452    #[inline(always)]
453    unsafe fn set_len(&mut self, new_len: usize) {
454        unsafe { self.data.set_len(new_len) }
455    }
456
457    fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>
458    where
459        F: FnMut(&T) -> Ordering,
460    {
461        self.data.binary_search_by(f)
462    }
463
464    fn sort(&mut self)
465    where
466        T: Ord,
467    {
468        self.data.sort();
469    }
470
471    fn sort_by<F>(&mut self, compare: F)
472    where
473        F: FnMut(&T, &T) -> Ordering,
474    {
475        self.data.sort_by(compare)
476    }
477
478    fn sort_by_key<K, F>(&mut self, f: F)
479    where
480        F: FnMut(&T) -> K,
481        K: Ord,
482    {
483        self.data.sort_by_key(f)
484    }
485
486    fn capacity_bound(&self) -> usize {
487        usize::MAX
488    }
489}
490
491#[cfg(test)]
492mod tests {
493    use crate::prelude::*;
494    use alloc::string::String;
495    use alloc::vec::Vec;
496    use orx_pinned_vec::*;
497    use orx_pseudo_default::PseudoDefault;
498
499    #[test]
500    fn pinned_vec_exact_capacity() {
501        #[cfg(not(miri))]
502        let capacities = [0, 124, 5421];
503        #[cfg(miri)]
504        let capacities = [0, 44];
505
506        for cap in capacities {
507            test_pinned_vec(FixedVec::new(cap), cap);
508        }
509    }
510
511    #[test]
512    fn pinned_vec_loose_capacity() {
513        #[cfg(not(miri))]
514        let capacities = [0, 124, 5421];
515        #[cfg(miri)]
516        let capacities = [0, 44];
517
518        for cap in capacities {
519            test_pinned_vec(FixedVec::new(cap * 2), cap);
520        }
521    }
522
523    #[test]
524    fn into_inner() {
525        let fixed: FixedVec<_> = (0..16).collect();
526        let vec = fixed.into_inner();
527        assert_eq!(vec, (0..16).collect::<Vec<_>>())
528    }
529
530    #[test]
531    fn index_of_and_contains() {
532        fn test(mut vec: FixedVec<usize>) {
533            let mut another_vec = Vec::new();
534            for i in 0..42 {
535                vec.push(i);
536                another_vec.push(i);
537            }
538            for i in 0..vec.len() {
539                assert_eq!(Some(i), vec.index_of(&vec[i]));
540                assert!(vec.contains_reference(&vec[i]));
541
542                assert_eq!(None, vec.index_of(&another_vec[i]));
543                assert!(!vec.contains_reference(&another_vec[i]));
544
545                let scalar = another_vec[i];
546                assert_eq!(None, vec.index_of(&scalar));
547                assert!(!vec.contains_reference(&scalar));
548            }
549        }
550        test(FixedVec::new(42));
551        test(FixedVec::new(1000));
552    }
553
554    #[test]
555    fn len_and_is_empty() {
556        fn test_len(mut vec: FixedVec<usize>) {
557            for i in 0..42 {
558                assert_eq!(i, vec.len());
559                vec.push(i);
560            }
561            assert_eq!(42, vec.len());
562
563            vec.clear();
564            assert_eq!(0, vec.len());
565
566            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
567            assert_eq!(42, vec.len());
568
569            for i in 0..42 {
570                assert_eq!(42 - i, vec.len());
571                vec.pop();
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(vec.len() / 2);
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(0);
586            }
587            assert_eq!(0, vec.len());
588
589            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
590            for i in 0..42 {
591                assert_eq!(42 - i, vec.len());
592                vec.remove(vec.len() - 1);
593            }
594            assert_eq!(0, vec.len());
595
596            vec.clear();
597            for i in 0..42 {
598                assert_eq!(i, vec.len());
599                vec.insert(i, i);
600            }
601            assert_eq!(42, vec.len());
602
603            vec.clear();
604            for i in 0..42 {
605                assert_eq!(i, vec.len());
606                vec.insert(0, i);
607            }
608            assert_eq!(42, vec.len());
609        }
610
611        test_len(FixedVec::new(42));
612        test_len(FixedVec::new(1_000));
613    }
614
615    #[test]
616    fn capacity() {
617        let vec: FixedVec<char> = FixedVec::new(44);
618        assert_eq!(44, vec.capacity());
619        assert_eq!(CapacityState::FixedCapacity(44), vec.capacity_state());
620    }
621
622    #[test]
623    fn clear() {
624        fn clear_is_empty(mut vec: FixedVec<usize>) {
625            vec.clear();
626            assert!(vec.is_empty());
627            assert_eq!(0, vec.len());
628
629            vec.push(1);
630            assert!(!vec.is_empty());
631            for i in 0..42 {
632                vec.push(i);
633            }
634            assert!(!vec.is_empty());
635
636            vec.clear();
637            assert!(vec.is_empty());
638            assert_eq!(0, vec.len());
639        }
640        clear_is_empty(FixedVec::new(43));
641        clear_is_empty(FixedVec::new(1000));
642    }
643
644    #[test]
645    fn get() {
646        fn test_get(mut vec: FixedVec<usize>) {
647            assert!(vec.is_empty());
648
649            for i in 0..53 {
650                vec.push(i);
651
652                assert_eq!(vec.get(i), Some(&i));
653                assert_eq!(vec.get(i + 1), None);
654
655                *vec.get_mut(i).expect("is-some") += 100;
656                *unsafe { vec.get_unchecked_mut(i) } += 10;
657            }
658
659            for i in 0..53 {
660                assert_eq!(vec.get(i), Some(&(110 + i)));
661                assert_eq!(unsafe { vec.get_unchecked(i) }, &(110 + i));
662            }
663        }
664        test_get(FixedVec::new(53));
665        test_get(FixedVec::new(1000));
666    }
667
668    #[test]
669    fn first_last() {
670        let mut vec = FixedVec::new(6);
671
672        assert!(vec.first().is_none());
673        assert!(vec.last().is_none());
674
675        vec.push(42);
676
677        assert_eq!(vec.first(), Some(&42));
678        assert_eq!(vec.last(), Some(&42));
679
680        unsafe {
681            assert_eq!(vec.first_unchecked(), &42);
682            assert_eq!(vec.last_unchecked(), &42);
683        }
684
685        vec.push(7);
686
687        assert_eq!(vec.first(), Some(&42));
688        assert_eq!(vec.last(), Some(&7));
689
690        unsafe {
691            assert_eq!(vec.first_unchecked(), &42);
692            assert_eq!(vec.last_unchecked(), &7);
693        }
694
695        vec.insert(1, 56421);
696
697        assert_eq!(vec.first(), Some(&42));
698        assert_eq!(vec.last(), Some(&7));
699
700        unsafe {
701            assert_eq!(vec.first_unchecked(), &42);
702            assert_eq!(vec.last_unchecked(), &7);
703        }
704
705        vec.clear();
706
707        assert!(vec.first().is_none());
708        assert!(vec.last().is_none());
709    }
710
711    #[test]
712    fn extend_from_slice() {
713        fn test(mut vec: FixedVec<usize>) {
714            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
715            vec.extend_from_slice(&(42..63).collect::<Vec<_>>());
716            vec.extend_from_slice(&(63..100).collect::<Vec<_>>());
717
718            assert_eq!(100, vec.len());
719            for i in 0..100 {
720                assert_eq!(Some(&i), vec.get(i));
721            }
722        }
723        test(FixedVec::new(100));
724        test(FixedVec::new(1000));
725    }
726
727    #[test]
728    fn grow() {
729        fn test(mut vec: FixedVec<usize>) {
730            for i in 0..42 {
731                vec.push(i);
732            }
733            for i in 0..42 {
734                vec.insert(i, 100 + i);
735            }
736
737            for i in 0..42 {
738                assert_eq!(Some(&i), vec.get(42 + i));
739                assert_eq!(Some(&(100 + i)), vec.get(i));
740            }
741        }
742        test(FixedVec::new(84));
743        test(FixedVec::new(1000));
744    }
745
746    #[test]
747    fn shrink() {
748        fn test(mut vec: FixedVec<usize>) {
749            for i in 0..42 {
750                vec.push(i);
751                assert_eq!(i, vec.remove(0));
752                assert!(vec.is_empty());
753            }
754
755            for i in 0..42 {
756                vec.push(i);
757            }
758            for i in 0..42 {
759                assert_eq!(i, vec.remove(0));
760            }
761            assert!(vec.is_empty());
762
763            for i in 0..42 {
764                vec.push(i);
765            }
766            for i in (0..42).rev() {
767                assert_eq!(Some(i), vec.pop());
768            }
769            assert_eq!(None, vec.pop());
770            assert!(vec.is_empty());
771
772            for i in 0..42 {
773                vec.push(i);
774            }
775            for _ in 0..42 {
776                vec.remove(vec.len() / 2);
777            }
778            assert!(vec.is_empty());
779        }
780        test(FixedVec::new(42));
781        test(FixedVec::new(1000));
782    }
783
784    #[test]
785    fn swap() {
786        fn test(mut vec: FixedVec<usize>) {
787            for i in 0..42 {
788                vec.push(i);
789            }
790
791            for i in 0..21 {
792                vec.swap(i, 21 + i);
793            }
794
795            for i in 0..21 {
796                assert_eq!(21 + i, vec[i]);
797            }
798            for i in 21..42 {
799                assert_eq!(i - 21, vec[i]);
800            }
801        }
802        test(FixedVec::new(42));
803        test(FixedVec::new(1000));
804    }
805    #[test]
806    fn truncate() {
807        fn test(mut vec: FixedVec<usize>) {
808            for i in 0..42 {
809                vec.push(i);
810            }
811
812            vec.truncate(100);
813            assert_eq!(vec, (0..42).collect::<Vec<_>>());
814
815            vec.truncate(21);
816            assert_eq!(vec, (0..21).collect::<Vec<_>>());
817        }
818        test(FixedVec::new(42));
819        test(FixedVec::new(1000));
820    }
821
822    #[test]
823    fn eq() {
824        fn test(mut vec: FixedVec<usize>) {
825            let slice = &(0..42).collect::<Vec<usize>>();
826            for i in 0..42 {
827                vec.push(i);
828            }
829            assert!(vec.eq(slice));
830
831            vec.remove(7);
832            assert!(!vec.eq(slice));
833        }
834
835        test(FixedVec::new(142));
836        test(FixedVec::new(1000));
837    }
838
839    #[test]
840    fn clone() {
841        fn test(mut vec: FixedVec<usize>) {
842            assert!(vec.is_empty());
843
844            for i in 0..53 {
845                vec.push(i);
846            }
847
848            let clone = vec.clone();
849            assert_eq!(vec, clone);
850        }
851
852        test(FixedVec::new(53));
853        test(FixedVec::new(1000));
854    }
855
856    #[test]
857    fn slices() {
858        #![allow(for_loops_over_fallibles)]
859        let mut vec = FixedVec::new(184);
860
861        for i in 0..184 {
862            assert!(vec.slices(i..i + 1).is_none());
863            assert!(vec.slices(0..i + 1).is_none());
864            vec.push(i);
865        }
866
867        let slice = vec.slices(0..vec.len());
868        let mut combined = Vec::new();
869        for s in slice {
870            combined.extend_from_slice(s);
871        }
872        for i in 0..184 {
873            assert_eq!(i, vec[i]);
874            assert_eq!(i, combined[i]);
875        }
876
877        let begin = vec.len() / 4;
878        let end = 3 * vec.len() / 4;
879        let slice = vec.slices(begin..end);
880        let mut combined = Vec::new();
881        for s in slice {
882            combined.extend_from_slice(s);
883        }
884        for i in begin..end {
885            assert_eq!(i, vec[i]);
886            assert_eq!(i, combined[i - begin]);
887        }
888    }
889
890    #[test]
891    fn slices_mut() {
892        #![allow(for_loops_over_fallibles)]
893        let mut vec = FixedVec::new(184);
894
895        for i in 0..184 {
896            assert!(vec.slices_mut(i..i + 1).is_none());
897            assert!(vec.slices_mut(0..i + 1).is_none());
898            vec.push(i);
899        }
900
901        let slice = vec.slices_mut(0..vec.len());
902        let mut combined = Vec::new();
903        for s in slice {
904            combined.extend_from_slice(s);
905        }
906        for i in 0..184 {
907            assert_eq!(i, vec[i]);
908            assert_eq!(i, combined[i]);
909        }
910
911        let begin = vec.len() / 4;
912        let end = 3 * vec.len() / 4;
913        let slice = vec.slices_mut(begin..end);
914        let mut combined = Vec::new();
915        for s in slice {
916            combined.extend_from_slice(s);
917        }
918        for i in begin..end {
919            assert_eq!(i, vec[i]);
920            assert_eq!(i, combined[i - begin]);
921        }
922
923        vec.clear();
924
925        for _ in 0..184 {
926            vec.push(0);
927        }
928
929        fn update(slice: Option<&mut [usize]>, begin: usize) {
930            let mut val = begin;
931            for s in slice {
932                for x in s {
933                    *x = val;
934                    val += 1;
935                }
936            }
937        }
938        let mut fill = |begin: usize, end: usize| {
939            let range = begin..end;
940            update(vec.slices_mut(range), begin);
941        };
942
943        fill(0, 14);
944        fill(14, 56);
945        fill(56, 77);
946        fill(77, 149);
947        fill(149, 182);
948        fill(182, 184);
949        for i in 0..184 {
950            assert_eq!(vec.get(i), Some(&i));
951        }
952    }
953
954    #[test]
955    fn iter_iter_mut() {
956        let mut vec = FixedVec::new(4);
957        vec.push('a');
958        vec.push('b');
959
960        let mut iter = vec.iter();
961        assert_eq!(Some(&'a'), iter.next());
962        assert_eq!(Some(&'b'), iter.next());
963        assert_eq!(None, iter.next());
964
965        for x in vec.iter_mut() {
966            *x = 'x';
967        }
968
969        let mut iter = vec.iter();
970        assert_eq!(Some(&'x'), iter.next());
971        assert_eq!(Some(&'x'), iter.next());
972        assert_eq!(None, iter.next());
973    }
974
975    #[test]
976    fn rev_iter_iter_mut() {
977        let mut vec = FixedVec::new(4);
978        vec.push('a');
979        vec.push('b');
980
981        let mut iter = vec.iter_rev();
982        assert_eq!(Some(&'b'), iter.next());
983        assert_eq!(Some(&'a'), iter.next());
984        assert_eq!(None, iter.next());
985
986        for x in vec.iter_mut_rev() {
987            *x = 'x';
988        }
989
990        let mut iter = vec.iter_rev();
991        assert_eq!(Some(&'x'), iter.next());
992        assert_eq!(Some(&'x'), iter.next());
993        assert_eq!(None, iter.next());
994    }
995
996    #[derive(Debug, PartialEq, Clone)]
997    struct Num(usize);
998    #[test]
999    fn insert() {
1000        fn test(mut vec: FixedVec<Num>) {
1001            for i in 0..42 {
1002                vec.push(Num(i));
1003            }
1004            for i in 0..42 {
1005                vec.insert(i, Num(100 + i));
1006            }
1007
1008            for i in 0..42 {
1009                assert_eq!(Some(&Num(i)), vec.get(42 + i));
1010                assert_eq!(Some(&Num(100 + i)), vec.get(i));
1011            }
1012        }
1013        test(FixedVec::new(84));
1014        test(FixedVec::new(1000));
1015    }
1016
1017    #[test]
1018    fn pseudo_default() {
1019        let vec = FixedVec::<String>::pseudo_default();
1020        assert_eq!(0, vec.capacity());
1021        assert_eq!(0, vec.len());
1022    }
1023}
orx_fixed_vec/pinned_vec.rs

orx_fixed_vec/
pinned_vec.rs
