1 use crate::error::OutOfMemory; 2 use core::{ 3 fmt, mem, 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(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 mem::forget(self); 93 (ptr, len, cap) 94 } 95 96 /// Same as [`std::vec::Vec::from_raw_parts`]. 97 pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Self { 98 Vec { 99 // Safety: Same as our unsafe contract. 100 inner: unsafe { StdVec::from_raw_parts(ptr, length, capacity) }, 101 } 102 } 103 104 /// Same as [`std::vec::Vec::drain`]. 105 pub fn drain<R>(&mut self, range: R) -> std_alloc::vec::Drain<'_, T> 106 where 107 R: core::ops::RangeBounds<usize>, 108 { 109 self.inner.drain(range) 110 } 111 } 112 113 impl<T> Deref for Vec<T> { 114 type Target = [T]; 115 116 fn deref(&self) -> &Self::Target { 117 &self.inner 118 } 119 } 120 121 impl<T> DerefMut for Vec<T> { 122 fn deref_mut(&mut self) -> &mut Self::Target { 123 &mut self.inner 124 } 125 } 126 127 impl<T> Index<usize> for Vec<T> { 128 type Output = T; 129 130 fn index(&self, index: usize) -> &Self::Output { 131 &self.inner[index] 132 } 133 } 134 135 impl<T> IndexMut<usize> for Vec<T> { 136 fn index_mut(&mut self, index: usize) -> &mut Self::Output { 137 &mut self.inner[index] 138 } 139 } 140 141 impl<'a, T> IntoIterator for &'a Vec<T> { 142 type Item = &'a T; 143 144 type IntoIter = core::slice::Iter<'a, T>; 145 146 fn into_iter(self) -> Self::IntoIter { 147 (**self).iter() 148 } 149 } 150 151 impl<'a, T> IntoIterator for &'a mut Vec<T> { 152 type Item = &'a mut T; 153 154 type IntoIter = core::slice::IterMut<'a, T>; 155 156 fn into_iter(self) -> Self::IntoIter { 157 (**self).iter_mut() 158 } 159 } 160