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