orx_fixed_vec/
pinned_vec.rs

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

orx_fixed_vec/
pinned_vec.rs
