alloc_checked/
vec.rs

1use crate::claim::Claim;
2use crate::try_clone::TryClone;
3use alloc::alloc::Allocator;
4use alloc::collections::TryReserveError;
5use alloc::vec::Vec as InnerVec;
6use core::fmt::Debug;
7use core::ops::{Deref, DerefMut, Index, IndexMut};
8use core::slice::SliceIndex;
9
10pub struct Vec<T, A: Allocator> {
11    inner: InnerVec<T, A>,
12}
13
14impl<T, A: Allocator> Vec<T, A> {
15    #[inline]
16    pub fn new_in(alloc: A) -> Self {
17        Self {
18            inner: InnerVec::new_in(alloc),
19        }
20    }
21
22    pub fn allocator(&self) -> &A {
23        self.inner.allocator()
24    }
25
26    #[inline]
27    pub fn capacity(&self) -> usize {
28        self.inner.capacity()
29    }
30
31    #[inline]
32    pub fn reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
33        self.inner.try_reserve(additional)
34    }
35
36    #[inline]
37    pub fn with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserveError> {
38        Ok(Self {
39            inner: InnerVec::try_with_capacity_in(capacity, alloc)?,
40        })
41    }
42
43    #[inline]
44    pub fn push(&mut self, value: T) -> Result<(), TryReserveError> {
45        self.reserve(1)?;
46        // SAFETY: we just reserved space for one more element.
47        unsafe {
48            self.unsafe_push(value);
49        }
50        Ok(())
51    }
52
53    #[inline]
54    unsafe fn unsafe_push(&mut self, value: T) {
55        let len = self.inner.len();
56        let end = self.inner.as_mut_ptr().add(len);
57        core::ptr::write(end, value);
58        self.inner.set_len(len + 1)
59    }
60
61    pub fn extend(&mut self, iter: impl IntoIterator<Item = T>) -> Result<(), TryReserveError> {
62        let mut iter = iter.into_iter();
63        let (lower_bound, _) = iter.size_hint();
64
65        // Extend N with pre-allocation from the iterator
66        self.reserve(lower_bound)?;
67        for _ in 0..lower_bound {
68            let Some(value) = iter.next() else {
69                return Ok(());
70            };
71            unsafe {
72                self.unsafe_push(value);
73            }
74        }
75
76        // Dynamically append the rest
77        for value in iter {
78            self.push(value)?;
79        }
80        Ok(())
81    }
82
83    #[inline]
84    pub fn iter(&self) -> core::slice::Iter<'_, T> {
85        self.inner.iter()
86    }
87
88    #[inline]
89    pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, T> {
90        self.inner.iter_mut()
91    }
92
93    #[inline]
94    pub fn len(&self) -> usize {
95        self.inner.len()
96    }
97
98    #[inline]
99    pub fn is_empty(&self) -> bool {
100        self.inner.is_empty()
101    }
102
103    #[inline]
104    pub fn as_slice(&self) -> &[T] {
105        self
106    }
107
108    #[inline]
109    pub fn as_ptr(&self) -> *const T {
110        self.inner.as_ptr()
111    }
112
113    #[inline]
114    pub fn as_mut_ptr(&mut self) -> *mut T {
115        self.inner.as_mut_ptr()
116    }
117
118    #[inline]
119    pub fn clear(&mut self) {
120        self.inner.clear();
121    }
122
123    #[inline]
124    pub fn truncate(&mut self, new_len: usize) {
125        self.inner.truncate(new_len);
126    }
127
128    #[inline]
129    pub fn resize_with<F: FnMut() -> T>(
130        &mut self,
131        new_len: usize,
132        mut f: F,
133    ) -> Result<(), TryReserveError> {
134        let len = self.len();
135        if new_len > len {
136            self.reserve(new_len - len)?;
137            for index in len..new_len {
138                unsafe {
139                    let end = self.inner.as_mut_ptr().add(index);
140                    core::ptr::write(end, f());
141                }
142            }
143            unsafe { self.inner.set_len(new_len) }
144        } else {
145            self.truncate(new_len);
146        }
147        Ok(())
148    }
149}
150
151impl<T: Claim, A: Allocator> Vec<T, A> {
152    #[inline]
153    pub fn extend_from_slice(&mut self, slice: &[T]) -> Result<(), TryReserveError> {
154        self.reserve(slice.len())?;
155
156        // Yes, we re-evaluate the capacity by delegating to the inner Vec,
157        // but we also gain the optimizations available via specific implementations
158        // for anything that supports the `Copy` trait.
159        self.inner.extend_from_slice(slice);
160        Ok(())
161    }
162
163    #[inline]
164    pub fn extend_with(&mut self, additional: usize, value: T) -> Result<(), TryReserveError> {
165        self.reserve(additional)?;
166        let len = self.inner.len();
167        let new_len = len + additional;
168        for index in len..new_len {
169            unsafe {
170                let end = self.inner.as_mut_ptr().add(index);
171                core::ptr::write(end, value.clone());
172            }
173        }
174        unsafe { self.inner.set_len(new_len) }
175        Ok(())
176    }
177
178    #[inline]
179    pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), TryReserveError> {
180        let len = self.len();
181        if new_len > len {
182            self.extend_with(new_len - len, value)?;
183        } else {
184            self.truncate(new_len);
185        }
186        Ok(())
187    }
188}
189
190impl<T: Claim, A: Allocator + Claim> TryClone for Vec<T, A> {
191    type Error = TryReserveError;
192
193    fn try_clone(&self) -> Result<Self, Self::Error> {
194        let mut cloned = Self::with_capacity_in(self.len(), self.allocator().clone())?;
195        cloned.extend_from_slice(self.inner.as_slice())?;
196        Ok(cloned)
197    }
198}
199
200impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A> {
201    type Output = I::Output;
202
203    #[inline]
204    fn index(&self, index: I) -> &Self::Output {
205        self.inner.index(index)
206    }
207}
208
209impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A> {
210    #[inline]
211    fn index_mut(&mut self, index: I) -> &mut Self::Output {
212        self.inner.index_mut(index)
213    }
214}
215
216impl<T, A: Allocator> Deref for Vec<T, A> {
217    type Target = [T];
218
219    fn deref(&self) -> &Self::Target {
220        &self.inner
221    }
222}
223
224impl<T, A: Allocator> DerefMut for Vec<T, A> {
225    fn deref_mut(&mut self) -> &mut Self::Target {
226        &mut self.inner
227    }
228}
229
230impl<T: Debug, A: Allocator> Debug for Vec<T, A> {
231    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
232        self.inner.fmt(f)
233    }
234}
235
236macro_rules! __impl_slice_eq1 {
237    ([$($vars:tt)*] $lhs:ty, $rhs:ty $(where $ty:ty: $bound:ident)?) => {
238        impl<T, U, $($vars)*> PartialEq<$rhs> for $lhs
239        where
240            T: PartialEq<U>,
241            $($ty: $bound)?
242        {
243            #[inline]
244            fn eq(&self, other: &$rhs) -> bool { self[..] == other[..] }
245
246            #[allow(clippy::partialeq_ne_impl)]
247            #[inline]
248            fn ne(&self, other: &$rhs) -> bool { self[..] != other[..] }
249        }
250    }
251}
252
253__impl_slice_eq1! { [A1: Allocator, A2: Allocator] Vec<T, A1>, Vec<U, A2> }
254__impl_slice_eq1! { [A: Allocator] Vec<T, A>, &[U] }
255__impl_slice_eq1! { [A: Allocator] Vec<T, A>, &mut [U] }
256__impl_slice_eq1! { [A: Allocator] &[T], Vec<U, A> }
257__impl_slice_eq1! { [A: Allocator] &mut [T], Vec<U, A> }
258__impl_slice_eq1! { [A: Allocator] Vec<T, A>, [U] }
259__impl_slice_eq1! { [A: Allocator] [T], Vec<U, A> }
260__impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, [U; N] }
261__impl_slice_eq1! { [A: Allocator, const N: usize] [T; N], Vec<U, A> }
262__impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, &[U; N] }
263__impl_slice_eq1! { [A: Allocator, const N: usize] &[T; N], Vec<U, A> }
264
265impl<T, A: Allocator> AsRef<Vec<T, A>> for Vec<T, A> {
266    fn as_ref(&self) -> &Vec<T, A> {
267        self
268    }
269}
270
271impl<T, A: Allocator> AsMut<Vec<T, A>> for Vec<T, A> {
272    fn as_mut(&mut self) -> &mut Vec<T, A> {
273        self
274    }
275}
276
277impl<T, A: Allocator> AsRef<[T]> for Vec<T, A> {
278    fn as_ref(&self) -> &[T] {
279        self
280    }
281}
282
283impl<T, A: Allocator> AsMut<[T]> for Vec<T, A> {
284    fn as_mut(&mut self) -> &mut [T] {
285        self
286    }
287}
288
289#[cfg(test)]
290mod tests {
291    use super::*;
292    use crate::claim::Claim;
293    use alloc::alloc::Global;
294    use alloc::boxed::Box;
295    use alloc::collections::TryReserveError;
296    use alloc::sync::Arc;
297    use alloc::{format, vec};
298    use core::alloc::{AllocError, Layout};
299    use core::ptr::NonNull;
300    use core::sync::atomic::{AtomicUsize, Ordering};
301
302    #[derive(Clone)]
303    struct WatermarkAllocator {
304        watermark: usize,
305        in_use: Arc<AtomicUsize>,
306    }
307
308    impl Claim for WatermarkAllocator {}
309
310    impl WatermarkAllocator {
311        pub(crate) fn in_use(&self) -> usize {
312            self.in_use.load(Ordering::SeqCst)
313        }
314    }
315
316    impl WatermarkAllocator {
317        fn new(watermark: usize) -> Self {
318            Self {
319                watermark,
320                in_use: AtomicUsize::new(0).into(),
321            }
322        }
323    }
324
325    unsafe impl Allocator for WatermarkAllocator {
326        fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
327            let current_in_use = self.in_use.load(Ordering::SeqCst);
328            let new_in_use = current_in_use + layout.size();
329            if new_in_use > self.watermark {
330                return Err(AllocError);
331            }
332            let allocated = Global.allocate(layout)?;
333            let true_new_in_use = self.in_use.fetch_add(allocated.len(), Ordering::SeqCst);
334            unsafe {
335                if true_new_in_use > self.watermark {
336                    let ptr = allocated.as_ptr() as *mut u8;
337                    let to_dealloc = NonNull::new_unchecked(ptr);
338                    Global.deallocate(to_dealloc, layout);
339                    Err(AllocError)
340                } else {
341                    Ok(allocated)
342                }
343            }
344        }
345
346        unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
347            Global.deallocate(ptr, layout);
348            self.in_use.fetch_sub(layout.size(), Ordering::SeqCst);
349        }
350    }
351
352    #[test]
353    fn test_basics() {
354        let wma = WatermarkAllocator::new(32);
355        let mut vec = Vec::new_in(wma.clone());
356        assert_eq!(vec.len(), 0);
357        assert_eq!(vec.capacity(), 0);
358        assert!(vec.is_empty());
359        vec.push(1).unwrap();
360        assert_eq!(vec.len(), 1);
361        assert!(!vec.is_empty());
362        vec.push(2).unwrap();
363        vec.push(3).unwrap();
364        vec.push(4).unwrap();
365        assert_eq!(vec.len(), 4);
366        assert_eq!(vec.capacity(), 4);
367        assert_eq!(
368            wma.in_use.load(Ordering::SeqCst),
369            vec.capacity() * size_of::<i32>()
370        );
371        assert_eq!(
372            vec.allocator().in_use.load(Ordering::SeqCst),
373            vec.capacity() * size_of::<i32>()
374        );
375        let _err: TryReserveError = vec.push(5).unwrap_err();
376        assert_eq!(vec.as_slice(), &[1, 2, 3, 4]);
377        assert_eq!(vec.len(), 4);
378        vec.clear();
379        assert_eq!(vec.len(), 0);
380        assert!(vec.is_empty());
381        assert_eq!(vec.capacity(), 4);
382    }
383
384    #[test]
385    fn test_with_capacity_in() {
386        let wma = WatermarkAllocator::new(32);
387        let vec: Vec<usize, _> = Vec::with_capacity_in(4, wma.clone()).unwrap();
388        assert_eq!(vec.len(), 0);
389        assert_eq!(vec.as_slice(), &[]);
390        assert_eq!(vec.inner.capacity(), 4);
391        assert_eq!(wma.in_use(), 4 * size_of::<usize>());
392
393        let _err: TryReserveError = Vec::<i8, _>::with_capacity_in(5, wma).unwrap_err();
394    }
395
396    #[test]
397    fn test_reserve() {
398        let wma = WatermarkAllocator::new(32);
399        let mut vec: Vec<bool, _> = Vec::new_in(wma);
400        vec.reserve(32).unwrap();
401        assert_eq!(vec.inner.capacity(), 32);
402
403        let _err: TryReserveError = vec.reserve(33).unwrap_err();
404    }
405
406    #[test]
407    fn test_fmt_debug() {
408        let wma = WatermarkAllocator::new(32);
409        let mut vec = Vec::new_in(wma);
410        vec.push(1).unwrap();
411        vec.push(2).unwrap();
412        vec.push(3).unwrap();
413        vec.push(4).unwrap();
414        assert_eq!(format!("{:?}", vec), "[1, 2, 3, 4]");
415    }
416
417    #[test]
418    fn test_iter() {
419        let wma = WatermarkAllocator::new(32);
420        let mut vec = Vec::new_in(wma);
421        vec.push(1).unwrap();
422        vec.push(2).unwrap();
423        vec.push(3).unwrap();
424        vec.push(4).unwrap();
425        let mut iter = vec.iter();
426        assert_eq!(iter.next(), Some(&1));
427        assert_eq!(iter.next(), Some(&2));
428        assert_eq!(iter.next(), Some(&3));
429        assert_eq!(iter.next(), Some(&4));
430        assert_eq!(iter.next(), None);
431    }
432
433    #[test]
434    fn test_iter_mut() {
435        let wma = WatermarkAllocator::new(32);
436        let mut vec = Vec::new_in(wma);
437        vec.push(1).unwrap();
438        vec.push(2).unwrap();
439        vec.push(3).unwrap();
440        vec.push(4).unwrap();
441        let mut iter = vec.iter_mut();
442        assert_eq!(iter.next(), Some(&mut 1));
443        assert_eq!(iter.next(), Some(&mut 2));
444        assert_eq!(iter.next(), Some(&mut 3));
445        assert_eq!(iter.next(), Some(&mut 4));
446        assert_eq!(iter.next(), None);
447    }
448
449    #[test]
450    fn test_as_ptr() {
451        let wma = WatermarkAllocator::new(32);
452        let mut vec = Vec::new_in(wma.clone());
453        assert_eq!(wma.in_use(), 0);
454        vec.push(1).unwrap();
455        vec.push(2).unwrap();
456        vec.push(3).unwrap();
457        vec.push(4).unwrap();
458        let ptr = vec.as_ptr();
459        unsafe {
460            assert_eq!(*ptr, 1);
461            assert_eq!(*ptr.add(1), 2);
462            assert_eq!(*ptr.add(2), 3);
463            assert_eq!(*ptr.add(3), 4);
464        }
465    }
466
467    #[test]
468    fn test_as_mut_ptr() {
469        let wma = WatermarkAllocator::new(64);
470        let mut vec = Vec::new_in(wma.clone());
471        assert_eq!(wma.in_use(), 0);
472        vec.push('a').unwrap();
473        vec.push('b').unwrap();
474        vec.push('c').unwrap();
475        vec.push('d').unwrap();
476        vec.push('e').unwrap();
477        vec.push('f').unwrap();
478        let ptr = vec.as_mut_ptr();
479        unsafe {
480            assert_eq!(*ptr, 'a');
481            assert_eq!(*ptr.add(1), 'b');
482            assert_eq!(*ptr.add(2), 'c');
483            assert_eq!(*ptr.add(3), 'd');
484            assert_eq!(*ptr.add(4), 'e');
485            assert_eq!(*ptr.add(5), 'f');
486        }
487    }
488
489    #[test]
490    fn test_index() {
491        let wma = WatermarkAllocator::new(32);
492        let mut vec = Vec::new_in(wma);
493        vec.push(1).unwrap();
494        vec.push(2).unwrap();
495        vec.push(3).unwrap();
496        vec.push(4).unwrap();
497        assert_eq!(vec[0], 1);
498        assert_eq!(vec[1], 2);
499        assert_eq!(vec[2], 3);
500        assert_eq!(vec[3], 4);
501    }
502
503    /// A type that implements `Clone` and `Claim`, but not `Copy`.
504    #[derive(Clone, Eq, PartialEq)]
505    struct Claimable(i32);
506
507    impl Claim for Claimable {}
508
509    #[test]
510    fn test_extend_from_slice_clone() {
511        let wma = WatermarkAllocator::new(32);
512        let mut vec = Vec::new_in(wma);
513        vec.extend_from_slice(&[Claimable(1), Claimable(2), Claimable(3), Claimable(4)])
514            .unwrap();
515    }
516
517    #[test]
518    fn test_extend_from_slice_copy() {
519        let wma = WatermarkAllocator::new(32);
520        let mut vec = Vec::new_in(wma);
521        vec.extend_from_slice(&[1, 2, 3, 4]).unwrap();
522        assert_eq!(vec.inner.as_slice(), &[1, 2, 3, 4]);
523
524        let _err: TryReserveError = vec.extend_from_slice(&[5, 6]).unwrap_err();
525
526        vec.extend_from_slice(&[]).unwrap();
527    }
528
529    #[test]
530    fn test_deref() {
531        let wma = WatermarkAllocator::new(32);
532        let mut vec = Vec::new_in(wma);
533        vec.push(1).unwrap();
534        vec.push(2).unwrap();
535        vec.push(3).unwrap();
536        vec.push(4).unwrap();
537        assert_eq!(&*vec, &[1, 2, 3, 4]);
538    }
539
540    #[test]
541    fn test_deref_mut() {
542        let wma = WatermarkAllocator::new(32);
543        let mut vec = Vec::new_in(wma);
544        vec.push(1).unwrap();
545        vec.push(2).unwrap();
546        vec.push(3).unwrap();
547        vec.push(4).unwrap();
548        let vec: &mut [i32] = &mut vec;
549        vec[0] = 5;
550        vec[1] = 6;
551        vec[2] = 7;
552        vec[3] = 8;
553        assert_eq!(&*vec, &[5, 6, 7, 8]);
554    }
555
556    struct MyIter {
557        counter: usize,
558        min_size_hint: usize,
559    }
560
561    impl MyIter {
562        fn new(min_size_hint: usize) -> Self {
563            Self {
564                counter: 0,
565                min_size_hint,
566            }
567        }
568    }
569
570    impl Iterator for MyIter {
571        type Item = usize;
572
573        fn next(&mut self) -> Option<Self::Item> {
574            if self.counter >= 10 {
575                return None;
576            }
577            self.counter += 1;
578            Some(self.counter - 1)
579        }
580
581        // This sort-of lies, but it's here for testing purposes.
582        // It states that the iterator has at least, just, 5 elements.
583        // This is done so we can get good code coverage and test both
584        // the optimised pre-reserve code path for `extend` and the
585        // slower dynamic re-allocation code path.
586        fn size_hint(&self) -> (usize, Option<usize>) {
587            (self.min_size_hint, None)
588        }
589    }
590
591    #[test]
592    fn test_extend() {
593        // Test the optimised with mixed pre-reserved and dynamic allocation extend paths.
594        let wma = WatermarkAllocator::new(32 * size_of::<usize>());
595        {
596            let mut vec = Vec::new_in(wma.clone());
597            vec.extend(MyIter::new(5)).unwrap();
598            assert_eq!(vec.inner.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
599        }
600        assert_eq!(wma.in_use(), 0);
601
602        // Test with a fully pre-reserved path.
603        {
604            let mut vec = Vec::new_in(wma.clone());
605            vec.extend(MyIter::new(10)).unwrap();
606            assert_eq!(vec.inner.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
607        }
608        assert_eq!(wma.in_use(), 0);
609
610        // Test with a fully pre-reserved path, but the `min` size_hint lies
611        // and exceeds the truth.
612        {
613            let mut vec = Vec::new_in(wma.clone());
614            vec.extend(MyIter::new(20)).unwrap();
615            assert_eq!(vec.inner.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
616        }
617        assert_eq!(wma.in_use(), 0);
618
619        // The min size hint is zero, all dynamically allocated.
620        {
621            let mut vec = Vec::new_in(wma.clone());
622            vec.extend(MyIter::new(0)).unwrap();
623            assert_eq!(vec.inner.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
624        }
625        assert_eq!(wma.in_use(), 0);
626    }
627
628    #[test]
629    fn test_truncate() {
630        let wma = WatermarkAllocator::new(32);
631        let mut vec = Vec::new_in(wma);
632        vec.push(1).unwrap();
633        vec.push(2).unwrap();
634        vec.push(3).unwrap();
635        vec.push(4).unwrap();
636        vec.truncate(2);
637        assert_eq!(vec.inner.as_slice(), &[1, 2]);
638        vec.truncate(0);
639        let empty: &[i32] = &[];
640        assert_eq!(vec.inner.as_slice(), empty);
641    }
642
643    #[test]
644    fn test_extend_with() {
645        let wma = WatermarkAllocator::new(32);
646        let mut vec = Vec::new_in(wma);
647        vec.extend_with(3, 1).unwrap();
648        assert_eq!(vec.inner.as_slice(), &[1, 1, 1]);
649    }
650
651    #[test]
652    fn test_resize() {
653        let wma = WatermarkAllocator::new(64);
654        let mut vec = Vec::new_in(wma);
655        vec.resize(3, 1).unwrap();
656        assert_eq!(vec.inner.as_slice(), &[1, 1, 1]);
657        vec.resize(5, 2).unwrap();
658        assert_eq!(vec.inner.as_slice(), &[1, 1, 1, 2, 2]);
659        vec.resize(2, 3).unwrap();
660        assert_eq!(vec.inner.as_slice(), &[1, 1]);
661    }
662
663    #[test]
664    fn test_resize_with() {
665        let wma = WatermarkAllocator::new(64);
666        let mut vec = Vec::new_in(wma);
667        vec.resize_with(3, || 1).unwrap();
668        assert_eq!(vec.inner.as_slice(), &[1, 1, 1]);
669        vec.resize_with(5, || 2).unwrap();
670        assert_eq!(vec.inner.as_slice(), &[1, 1, 1, 2, 2]);
671        vec.resize_with(2, || 3).unwrap();
672        assert_eq!(vec.inner.as_slice(), &[1, 1]);
673    }
674
675    #[derive(PartialEq, Debug)]
676    struct IntWrapper(pub i32);
677
678    impl PartialEq<i32> for IntWrapper {
679        fn eq(&self, other: &i32) -> bool {
680            self.0 == *other
681        }
682    }
683
684    impl PartialEq<IntWrapper> for i32 {
685        fn eq(&self, other: &IntWrapper) -> bool {
686            self == &other.0
687        }
688    }
689
690    fn w(i: i32) -> IntWrapper {
691        IntWrapper(i)
692    }
693
694    #[test]
695    fn test_eq() {
696        let wma = WatermarkAllocator::new(64);
697
698        // __impl_slice_eq1! { [A1: Allocator, A2: Allocator] Vec<T, A1>, Vec<U, A2> }
699        {
700            let mut lhs = Vec::new_in(wma.clone());
701            let mut rhs = Vec::new_in(Global);
702
703            lhs.extend(vec![1, 2, 3]).unwrap();
704            rhs.extend(vec![w(1), w(2), w(3)]).unwrap();
705            assert_eq!(lhs, rhs);
706            assert_eq!(rhs, lhs);
707
708            rhs.push(w(4)).unwrap();
709            assert_ne!(lhs, rhs);
710            assert_ne!(rhs, lhs);
711        }
712
713        // __impl_slice_eq1! { [A: Allocator] Vec<T, A>, &[U] }
714        // __impl_slice_eq1! { [A: Allocator] &[T], Vec<U, A> }
715        {
716            let mut lhs = Vec::new_in(wma.clone());
717            lhs.extend(vec![1, 2, 3]).unwrap();
718            let rhs: &[IntWrapper] = &[w(1), w(2), w(3)];
719            assert_eq!(lhs, rhs);
720            assert_eq!(rhs, lhs);
721
722            let rhs2: &[IntWrapper] = &[w(1), w(2), w(3), w(4)];
723            assert_ne!(lhs, rhs2);
724            assert_ne!(rhs2, lhs);
725        }
726
727        // __impl_slice_eq1! { [A: Allocator] Vec<T, A>, &mut [U] }
728        // __impl_slice_eq1! { [A: Allocator] &mut [T], Vec<U, A> }
729        {
730            let mut lhs = Vec::new_in(wma.clone());
731            lhs.extend(vec![1, 2, 3]).unwrap();
732
733            let mut rhs_vec = vec![w(1), w(2), w(3)];
734            let rhs: &mut [IntWrapper] = &mut rhs_vec;
735
736            assert_eq!(lhs, rhs);
737            assert_eq!(rhs, lhs);
738
739            rhs_vec.push(w(4));
740            let rhs2: &mut [IntWrapper] = &mut rhs_vec;
741            assert_ne!(lhs, rhs2);
742            assert_ne!(rhs2, lhs);
743        }
744
745        // __impl_slice_eq1! { [A: Allocator] Vec<T, A>, [U] }
746        // __impl_slice_eq1! { [A: Allocator] [T], Vec<U, A> }
747        {
748            let mut lhs = Vec::new_in(wma.clone());
749            lhs.extend(vec![1, 2, 3]).unwrap();
750
751            let rhs: Box<[IntWrapper]> = Box::new([w(1), w(2), w(3)]);
752            assert_eq!(lhs, *rhs);
753            assert_eq!(*rhs, lhs);
754
755            let rhs2: Box<[IntWrapper]> = Box::new([w(1), w(2), w(3), w(4)]);
756            assert_ne!(lhs, *rhs2);
757            assert_ne!(*rhs2, lhs);
758        }
759
760        // __impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, [U; N] }
761        // __impl_slice_eq1! { [A: Allocator, const N: usize] [T; N], Vec<U, A> }
762        {
763            let mut lhs = Vec::new_in(wma.clone());
764            lhs.extend(vec![1, 2, 3]).unwrap();
765
766            let rhs: [IntWrapper; 3] = [w(1), w(2), w(3)];
767            assert_eq!(lhs, rhs); // Compare Vec with fixed-size array
768            assert_eq!(rhs, lhs); // Compare fixed-size array with Vec
769
770            let rhs2: [IntWrapper; 4] = [w(1), w(2), w(3), w(4)];
771            assert_ne!(lhs, rhs2); // Compare Vec with longer array
772            assert_ne!(rhs2, lhs); // Compare longer array with Vec
773        }
774
775        // __impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, &[U; N] }
776        // __impl_slice_eq1! { [A: Allocator, const N: usize] &[T; N], Vec<U, A> }
777        {
778            let mut lhs = Vec::new_in(wma.clone());
779            lhs.extend(vec![1, 2, 3]).unwrap();
780
781            let rhs_arr: [IntWrapper; 3] = [w(1), w(2), w(3)];
782            let rhs: &[IntWrapper; 3] = &rhs_arr;
783            assert_eq!(lhs, rhs);
784            assert_eq!(rhs, lhs);
785
786            lhs.push(4).unwrap();
787            assert_ne!(lhs, rhs);
788            assert_ne!(rhs, lhs);
789        }
790    }
791
792    fn get_first_elem_vec<T: Claim, A: Allocator>(vec: impl AsRef<Vec<T, A>>) -> T {
793        let vec = vec.as_ref();
794        vec.first().unwrap().clone()
795    }
796
797    fn get_first_elem_slice<T: Claim>(slice: impl AsRef<[T]>) -> T {
798        let vec = slice.as_ref();
799        vec.first().unwrap().clone()
800    }
801
802    #[test]
803    fn test_as_ref() {
804        let wma = WatermarkAllocator::new(128);
805        let mut vec1 = Vec::new_in(wma);
806        vec1.extend(vec![1, 2, 3]).unwrap();
807        let vec2 = vec1.try_clone().unwrap();
808
809        assert_eq!(vec1, vec2);
810        let e0vec1 = get_first_elem_vec(vec1);
811        let e0vec2 = get_first_elem_slice(vec2);
812        assert_eq!(e0vec1, 1);
813        assert_eq!(e0vec2, 1);
814    }
815
816    fn doubled_first_elem_vec(mut vec: impl AsMut<Vec<i32, WatermarkAllocator>>) -> i32 {
817        let vec = vec.as_mut();
818        vec[0] *= 2;
819        vec[0]
820    }
821
822    fn doubled_first_elem_slice(mut vec: impl AsMut<[i32]>) -> i32 {
823        let vec = vec.as_mut();
824        vec[0] *= 2;
825        vec[0]
826    }
827
828    #[test]
829    fn test_as_mut() {
830        let wma = WatermarkAllocator::new(128);
831        let mut vec1 = Vec::new_in(wma);
832        vec1.extend(vec![1, 2, 3]).unwrap();
833        let vec2 = vec1.try_clone().unwrap();
834        assert_eq!(vec1, vec2);
835
836        let d0vec1 = doubled_first_elem_vec(vec1);
837        let d0vec2 = doubled_first_elem_slice(vec2);
838
839        assert_eq!(d0vec1, 2);
840        assert_eq!(d0vec2, 2);
841    }
842
843    #[test]
844    fn test_try_clone() {
845        let wma = WatermarkAllocator::new(64);
846        let mut vec1 = Vec::new_in(wma.clone());
847        vec1.extend([1usize, 2, 3, 4, 5, 6, 7, 8]).unwrap();
848        assert_eq!(vec1.len(), 8);
849        assert_eq!(vec1.capacity(), 8);
850        assert_eq!(wma.in_use(), 64);
851        assert!(vec1.try_clone().is_err());
852    }
853}
alloc_checked/vec.rs

alloc_checked/
vec.rs
