1 use crate::error::OutOfMemory; 2 use core::{ 3 fmt, 4 ops::{Deref, DerefMut, Index, IndexMut}, 5 }; 6 use std_alloc::vec::Vec as StdVec; 7 8 /// Like `std::vec::Vec` but all methods that allocate force handling allocation 9 /// failure. 10 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] 11 pub struct Vec<T> { 12 inner: StdVec<T>, 13 } 14 15 impl<T> Default for Vec<T> { 16 fn default() -> Self { 17 Self { 18 inner: Default::default(), 19 } 20 } 21 } 22 23 impl<T: fmt::Debug> fmt::Debug for Vec<T> { 24 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 25 fmt::Debug::fmt(&self.inner, f) 26 } 27 } 28 29 impl<T> Vec<T> { 30 /// Same as [`std::vec::Vec::new`]. 31 pub fn new() -> Self { 32 Default::default() 33 } 34 35 /// Same as [`std::vec::Vec::with_capacity`] but returns an error on 36 /// allocation failure. 37 pub fn with_capacity(capacity: usize) -> Result<Self, OutOfMemory> { 38 let mut v = Self::new(); 39 v.reserve(capacity)?; 40 Ok(v) 41 } 42 43 /// Same as [`std::vec::Vec::reserve`] but returns an error on allocation 44 /// failure. 45 pub fn reserve(&mut self, additional: usize) -> Result<(), OutOfMemory> { 46 self.inner.try_reserve(additional).map_err(|_| { 47 OutOfMemory::new( 48 self.len() 49 .saturating_add(additional) 50 .saturating_mul(core::mem::size_of::<T>()), 51 ) 52 }) 53 } 54 55 /// Same as [`std::vec::Vec::reserve_exact`] but returns an error on allocation 56 /// failure. 57 pub fn reserve_exact(&mut self, additional: usize) -> Result<(), OutOfMemory> { 58 self.inner 59 .try_reserve_exact(additional) 60 .map_err(|_| OutOfMemory::new(self.len().saturating_add(additional))) 61 } 62 63 /// Same as [`std::vec::Vec::len`]. 64 pub fn len(&self) -> usize { 65 self.inner.len() 66 } 67 68 /// Same as [`std::vec::Vec::capacity`]. 69 pub fn capacity(&self) -> usize { 70 self.inner.capacity() 71 } 72 73 /// Same as [`std::vec::Vec::is_empty`]. 74 pub fn is_empty(&self) -> bool { 75 self.inner.is_empty() 76 } 77 78 /// Same as [`std::vec::Vec::push`] but returns an error on allocation 79 /// failure. 80 pub fn push(&mut self, value: T) -> Result<(), OutOfMemory> { 81 self.reserve(1)?; 82 self.inner.push(value); 83 Ok(()) 84 } 85 86 /// Same as [`std::vec::Vec::into_raw_parts`]. 87 pub fn into_raw_parts(mut self) -> (*mut T, usize, usize) { 88 // NB: Can't use `Vec::into_raw_parts` until our MSRV is >= 1.93. 89 let ptr = self.as_mut_ptr(); 90 let len = self.len(); 91 let cap = self.capacity(); 92 (ptr, len, cap) 93 } 94 95 /// Same as [`std::vec::Vec::from_raw_parts`]. 96 pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Self { 97 Vec { 98 // Safety: Same as our unsafe contract. 99 inner: unsafe { StdVec::from_raw_parts(ptr, length, capacity) }, 100 } 101 } 102 103 /// Same as [`std::vec::Vec::drain`]. 104 pub fn drain<R>(&mut self, range: R) -> std_alloc::vec::Drain<'_, T> 105 where 106 R: core::ops::RangeBounds<usize>, 107 { 108 self.inner.drain(range) 109 } 110 } 111 112 impl<T> Deref for Vec<T> { 113 type Target = [T]; 114 115 fn deref(&self) -> &Self::Target { 116 &self.inner 117 } 118 } 119 120 impl<T> DerefMut for Vec<T> { 121 fn deref_mut(&mut self) -> &mut Self::Target { 122 &mut self.inner 123 } 124 } 125 126 impl<T> Index<usize> for Vec<T> { 127 type Output = T; 128 129 fn index(&self, index: usize) -> &Self::Output { 130 &self.inner[index] 131 } 132 } 133 134 impl<T> IndexMut<usize> for Vec<T> { 135 fn index_mut(&mut self, index: usize) -> &mut Self::Output { 136 &mut self.inner[index] 137 } 138 } 139 140 impl<'a, T> IntoIterator for &'a Vec<T> { 141 type Item = &'a T; 142 143 type IntoIter = core::slice::Iter<'a, T>; 144 145 fn into_iter(self) -> Self::IntoIter { 146 (**self).iter() 147 } 148 } 149 150 impl<'a, T> IntoIterator for &'a mut Vec<T> { 151 type Item = &'a mut T; 152 153 type IntoIter = core::slice::IterMut<'a, T>; 154 155 fn into_iter(self) -> Self::IntoIter { 156 (**self).iter_mut() 157 } 158 } 159