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::drain`]. 87 pub fn drain<R>(&mut self, range: R) -> std_alloc::vec::Drain<'_, T> 88 where 89 R: core::ops::RangeBounds<usize>, 90 { 91 self.inner.drain(range) 92 } 93 } 94 95 impl<T> Deref for Vec<T> { 96 type Target = [T]; 97 98 fn deref(&self) -> &Self::Target { 99 &self.inner 100 } 101 } 102 103 impl<T> DerefMut for Vec<T> { 104 fn deref_mut(&mut self) -> &mut Self::Target { 105 &mut self.inner 106 } 107 } 108 109 impl<T> Index<usize> for Vec<T> { 110 type Output = T; 111 112 fn index(&self, index: usize) -> &Self::Output { 113 &self.inner[index] 114 } 115 } 116 117 impl<T> IndexMut<usize> for Vec<T> { 118 fn index_mut(&mut self, index: usize) -> &mut Self::Output { 119 &mut self.inner[index] 120 } 121 } 122 123 impl<'a, T> IntoIterator for &'a Vec<T> { 124 type Item = &'a T; 125 126 type IntoIter = core::slice::Iter<'a, T>; 127 128 fn into_iter(self) -> Self::IntoIter { 129 (**self).iter() 130 } 131 } 132 133 impl<'a, T> IntoIterator for &'a mut Vec<T> { 134 type Item = &'a mut T; 135 136 type IntoIter = core::slice::IterMut<'a, T>; 137 138 fn into_iter(self) -> Self::IntoIter { 139 (**self).iter_mut() 140 } 141 } 142