use alloc::vec::Vec;
use core::{
iter::FusedIterator,
mem::{ManuallyDrop, MaybeUninit},
};
use zeroize::Zeroize;
pub(crate) fn clear<T>(values: &mut Vec<T>) {
values.clear();
values.spare_capacity_mut().zeroize();
}
pub(crate) fn reserve<T>(values: &mut Vec<T>, additional: usize) {
let needed = match values.len().checked_add(additional) {
Some(needed) => needed,
None => alloc::alloc::handle_alloc_error(alloc::alloc::Layout::new::<T>()),
};
if needed <= values.capacity() {
return;
}
let capacity = values
.capacity()
.checked_mul(2)
.unwrap_or(needed)
.max(needed);
let mut next = Vec::new();
if next.try_reserve_exact(capacity).is_err() {
alloc::alloc::handle_alloc_error(alloc::alloc::Layout::new::<T>());
}
next.append(values);
let mut previous = core::mem::replace(values, next);
previous.spare_capacity_mut().zeroize();
}
#[doc(hidden)]
pub struct IntoIter<T> {
slots: Vec<MaybeUninit<T>>,
front: usize,
back: usize,
erase: fn(&mut T),
}
impl<T> IntoIter<T> {
pub(crate) fn new(values: Vec<T>) -> Self {
Self::with_cleanup(values, |_| {})
}
pub(crate) fn with_cleanup(values: Vec<T>, erase: fn(&mut T)) -> Self {
let mut values = ManuallyDrop::new(values);
let length = values.len();
let slots = unsafe {
Vec::from_raw_parts(
values.as_mut_ptr().cast::<MaybeUninit<T>>(),
length,
values.capacity(),
)
};
Self {
slots,
front: 0,
back: length,
erase,
}
}
fn take(&mut self, index: usize) -> Option<T> {
let slot = self.slots.get_mut(index)?;
let value = unsafe { slot.assume_init_read() };
slot.zeroize();
Some(value)
}
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<T> {
if self.front == self.back {
return None;
}
let index = self.front;
self.front = self.front.checked_add(1)?;
self.take(index)
}
fn size_hint(&self) -> (usize, Option<usize>) {
match self.back.checked_sub(self.front) {
Some(remaining) => (remaining, Some(remaining)),
None => (0, Some(0)),
}
}
}
impl<T> DoubleEndedIterator for IntoIter<T> {
fn next_back(&mut self) -> Option<T> {
if self.front == self.back {
return None;
}
self.back = self.back.checked_sub(1)?;
self.take(self.back)
}
}
impl<T> ExactSizeIterator for IntoIter<T> {}
impl<T> FusedIterator for IntoIter<T> {}
impl<T> Drop for IntoIter<T> {
fn drop(&mut self) {
for slot in self.slots.iter_mut().take(self.back).skip(self.front) {
unsafe {
(self.erase)(slot.assume_init_mut());
slot.assume_init_drop();
}
}
self.slots.zeroize();
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::rc::Rc;
use core::cell::Cell;
struct Counted(Rc<Cell<usize>>);
impl Drop for Counted {
fn drop(&mut self) {
self.0.set(self.0.get() + 1);
}
}
#[test]
fn consuming_from_both_ends_drops_each_value_once() {
let dropped = Rc::new(Cell::new(0));
let mut iter = IntoIter::new((0..4).map(|_| Counted(dropped.clone())).collect());
assert_eq!(iter.len(), 4);
drop(iter.next());
drop(iter.next_back());
assert_eq!(dropped.get(), 2);
assert_eq!(iter.len(), 2);
drop(iter);
assert_eq!(dropped.get(), 4);
assert!(IntoIter::<u64>::new(Vec::new()).next().is_none());
}
}