1use super::{Zeroize, ZeroizeOnDrop};
3use alloc::vec::Vec;
4use core::{fmt, ops::Deref};
5
6pub struct List<T: Zeroize>(Vec<T>);
25impl<T: Zeroize> List<T> {
26 pub fn push(&mut self, value: T) {
28 if self.0.len() == self.0.capacity() {
29 let needed = match self.0.len().checked_add(1) {
32 Some(needed) => needed,
33 None => alloc::alloc::handle_alloc_error(alloc::alloc::Layout::new::<T>()),
34 };
35 let capacity = self
36 .0
37 .capacity()
38 .checked_mul(2)
39 .unwrap_or(needed)
40 .max(needed);
41 let mut next = Vec::new();
42 if next.try_reserve_exact(capacity).is_err() {
46 alloc::alloc::handle_alloc_error(alloc::alloc::Layout::new::<T>());
47 }
48 next.append(&mut self.0);
49 let mut previous = core::mem::replace(&mut self.0, next);
50 previous.zeroize();
52 }
53 self.0.push(value);
54 }
55 pub fn capacity(&self) -> usize {
57 self.0.capacity()
58 }
59 pub fn get_mut(&mut self, index: usize) -> Option<&mut T> {
61 self.0.get_mut(index)
62 }
63 pub fn iter_mut(&mut self) -> IterMut<'_, T> {
65 IterMut(self.0.iter_mut())
66 }
67 pub fn clear(&mut self) {
69 self.0.zeroize();
70 }
71}
72impl<T: Zeroize> Default for List<T> {
73 fn default() -> Self {
74 Self(Vec::new())
75 }
76}
77impl<T: Zeroize> Zeroize for List<T> {
78 fn zeroize(&mut self) {
79 self.clear();
80 }
81}
82impl<T: Zeroize> Drop for List<T> {
83 fn drop(&mut self) {
84 self.zeroize();
85 }
86}
87impl<T: Zeroize> ZeroizeOnDrop for List<T> {}
88impl<T: Zeroize + Clone> Clone for List<T> {
89 fn clone(&self) -> Self {
90 self.iter().cloned().collect()
91 }
92}
93impl<T: Zeroize + PartialEq> PartialEq for List<T> {
94 fn eq(&self, other: &Self) -> bool {
95 self.0 == other.0
96 }
97}
98impl<T: Zeroize + Eq> Eq for List<T> {}
99impl<T: Zeroize> fmt::Debug for List<T> {
100 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
101 f.write_str("List([REDACTED])")
102 }
103}
104impl<T: Zeroize> Deref for List<T> {
105 type Target = [T];
106 fn deref(&self) -> &[T] {
107 &self.0
108 }
109}
110impl<T: Zeroize> From<Vec<T>> for List<T> {
111 fn from(value: Vec<T>) -> Self {
112 Self(value)
113 }
114}
115impl<T: Zeroize> FromIterator<T> for List<T> {
116 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
117 let mut list = Self::default();
118 for value in iter {
119 list.push(value);
120 }
121 list
122 }
123}
124impl<T: Zeroize + Clone + PartialEq + fmt::Debug + Send + Sync> crate::ProtoList<T> for List<T> {
125 fn push(&mut self, value: T) {
126 self.push(value);
127 }
128 fn clear(&mut self) {
129 self.clear();
130 }
131}
132#[cfg(feature = "json")]
133impl<T: Zeroize + serde::Serialize> serde::Serialize for List<T> {
134 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
135 serde::Serialize::serialize(&*self.0, serializer)
136 }
137}
138#[cfg(feature = "json")]
139impl<'de, T: Zeroize + serde::Deserialize<'de>> serde::Deserialize<'de> for List<T> {
140 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
141 struct V<T>(core::marker::PhantomData<T>);
142 impl<'de, T: Zeroize + serde::Deserialize<'de>> serde::de::Visitor<'de> for V<T> {
143 type Value = List<T>;
144 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
145 f.write_str("an array")
146 }
147 fn visit_seq<A: serde::de::SeqAccess<'de>>(
148 self,
149 mut seq: A,
150 ) -> Result<Self::Value, A::Error> {
151 let mut list = List::default();
152 while let Some(value) = seq.next_element()? {
153 list.push(value);
154 }
155 Ok(list)
156 }
157 }
158 deserializer.deserialize_seq(V(core::marker::PhantomData))
159 }
160}
161
162impl<'a, T: Zeroize> IntoIterator for &'a List<T> {
163 type Item = &'a T;
164 type IntoIter = core::slice::Iter<'a, T>;
165 fn into_iter(self) -> Self::IntoIter {
166 self.iter()
167 }
168}
169impl<'a, T: Zeroize> IntoIterator for &'a mut List<T> {
170 type Item = &'a mut T;
171 type IntoIter = IterMut<'a, T>;
172 fn into_iter(self) -> Self::IntoIter {
173 self.iter_mut()
174 }
175}
176
177pub struct IterMut<'a, T>(core::slice::IterMut<'a, T>);
179impl<'a, T> Iterator for IterMut<'a, T> {
180 type Item = &'a mut T;
181 fn next(&mut self) -> Option<Self::Item> {
182 self.0.next()
183 }
184 fn size_hint(&self) -> (usize, Option<usize>) {
185 self.0.size_hint()
186 }
187}
188impl<T> DoubleEndedIterator for IterMut<'_, T> {
189 fn next_back(&mut self) -> Option<Self::Item> {
190 self.0.next_back()
191 }
192}
193impl<T> ExactSizeIterator for IterMut<'_, T> {}
194impl<T> core::iter::FusedIterator for IterMut<'_, T> {}
195impl<T> fmt::Debug for IterMut<'_, T> {
196 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
197 f.write_str("IterMut([REDACTED])")
198 }
199}
200
201impl<T: Zeroize> IntoIterator for List<T> {
202 type Item = T;
203 type IntoIter = super::ViewIntoIter<T>;
204 fn into_iter(mut self) -> Self::IntoIter {
205 Self::IntoIter::with_cleanup(core::mem::take(&mut self.0), T::zeroize)
206 }
207}
208
209#[cfg(test)]
210mod tests {
211 use super::*;
212 #[test]
213 fn growth_clone_and_clear_keep_values_owned() {
214 let mut values = List::default();
215 for n in 0..100u64 {
216 values.push(n);
217 }
218 assert_eq!(values.len(), 100);
219 let mut cloned = values.clone();
220 *cloned.get_mut(0).unwrap() = 42;
221 assert_eq!(values[0], 0);
222 assert_eq!(cloned[0], 42);
223 values.clear();
224 assert!(values.is_empty());
225 values.push(7);
226 assert_eq!(&*values, &[7]);
227 }
228
229 #[test]
230 fn mutable_iteration_keeps_elements_in_their_cleanup_owner() {
231 let mut values: List<u64> = [1, 2, 3].into_iter().collect();
232 assert!(values.get_mut(3).is_none());
233 let mut iter = values.iter_mut();
234 assert_eq!(iter.len(), 3);
235 *iter.next().unwrap() = 7;
236 *iter.next_back().unwrap() = 9;
237 assert_eq!(iter.len(), 1);
238 assert_eq!(alloc::format!("{iter:?}"), "IterMut([REDACTED])");
239 for value in &mut values {
240 *value += 1;
241 }
242 assert_eq!(&*values, &[8, 3, 10]);
243 }
244
245 #[test]
246 fn unconsumed_elements_are_zeroized_even_without_their_own_drop() {
247 use alloc::rc::Rc;
248 use core::cell::Cell;
249 struct Counted(Rc<Cell<usize>>);
250 impl Zeroize for Counted {
251 fn zeroize(&mut self) {
252 self.0.set(self.0.get() + 1);
253 }
254 }
255 let erased = Rc::new(Cell::new(0));
256 let mut values = List::default();
257 values.push(Counted(erased.clone()));
258 values.push(Counted(erased.clone()));
259 let mut iter = values.into_iter();
260 let mut transferred = iter.next().unwrap();
261 assert_eq!(erased.get(), 0);
262 drop(iter);
263 assert_eq!(erased.get(), 1);
264 transferred.zeroize();
265 assert_eq!(erased.get(), 2);
266 }
267 #[cfg(feature = "json")]
268 #[test]
269 fn native_serde_rejects_later_invalid_elements() {
270 let values: List<u64> = serde_json::from_str("[1,2,3]").unwrap();
271 assert_eq!(&*values, &[1, 2, 3]);
272 assert_eq!(serde_json::to_string(&values).unwrap(), "[1,2,3]");
273 assert!(serde_json::from_str::<List<u64>>("[1,2,[]]").is_err());
274 }
275}