mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-01 06:51:58 +00:00
Remove &[T] from vec_deque::Drain
This commit is contained in:
parent
4a6ac3c225
commit
25f4cb59d3
@ -1,7 +1,9 @@
|
||||
use core::fmt;
|
||||
use core::iter::{FusedIterator, TrustedLen, TrustedRandomAccess, TrustedRandomAccessNoCoerce};
|
||||
use core::marker::PhantomData;
|
||||
use core::mem::MaybeUninit;
|
||||
use core::ops::Try;
|
||||
use core::ptr::NonNull;
|
||||
|
||||
use super::{count, wrap_index, RingSlices};
|
||||
|
||||
@ -13,30 +15,45 @@ use super::{count, wrap_index, RingSlices};
|
||||
/// [`iter`]: super::VecDeque::iter
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct Iter<'a, T: 'a> {
|
||||
ring: &'a [MaybeUninit<T>],
|
||||
ring: NonNull<[T]>,
|
||||
tail: usize,
|
||||
head: usize,
|
||||
_marker: PhantomData<&'a T>,
|
||||
}
|
||||
|
||||
impl<'a, T> Iter<'a, T> {
|
||||
pub(super) fn new(ring: &'a [MaybeUninit<T>], tail: usize, head: usize) -> Self {
|
||||
Iter { ring, tail, head }
|
||||
Iter {
|
||||
ring: unsafe { NonNull::new_unchecked(ring as *const [MaybeUninit<T>] as *mut _) },
|
||||
tail,
|
||||
head,
|
||||
_marker: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn ring(&self) -> &'a [MaybeUninit<T>] {
|
||||
unsafe {
|
||||
core::slice::from_raw_parts(
|
||||
self.ring.as_ptr() as *const MaybeUninit<T>,
|
||||
self.ring.len(),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
unsafe impl<T: Sync> Sync for Iter<'_, T> {}
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
unsafe impl<T: Sync> Send for Iter<'_, T> {}
|
||||
|
||||
#[stable(feature = "collection_debug", since = "1.17.0")]
|
||||
impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
|
||||
let (front, back) = unsafe { RingSlices::ring_slices(self.ring(), self.head, self.tail) };
|
||||
// Safety:
|
||||
// - `self.head` and `self.tail` in a ring buffer are always valid indices.
|
||||
// - `RingSlices::ring_slices` guarantees that the slices split according to `self.head` and `self.tail` are initialized.
|
||||
unsafe {
|
||||
f.debug_tuple("Iter")
|
||||
.field(&MaybeUninit::slice_assume_init_ref(front))
|
||||
.field(&MaybeUninit::slice_assume_init_ref(back))
|
||||
.finish()
|
||||
}
|
||||
f.debug_tuple("Iter").field(&front).field(&back).finish()
|
||||
}
|
||||
}
|
||||
|
||||
@ -44,7 +61,7 @@ impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T> Clone for Iter<'_, T> {
|
||||
fn clone(&self) -> Self {
|
||||
Iter { ring: self.ring, tail: self.tail, head: self.head }
|
||||
Iter { ring: self.ring, tail: self.tail, head: self.head, _marker: PhantomData }
|
||||
}
|
||||
}
|
||||
|
||||
@ -62,7 +79,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
|
||||
// Safety:
|
||||
// - `self.tail` in a ring buffer is always a valid index.
|
||||
// - `self.head` and `self.tail` equality is checked above.
|
||||
unsafe { Some(self.ring.get_unchecked(tail).assume_init_ref()) }
|
||||
unsafe { Some(self.ring().get_unchecked(tail).assume_init_ref()) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -75,11 +92,11 @@ impl<'a, T> Iterator for Iter<'a, T> {
|
||||
where
|
||||
F: FnMut(Acc, Self::Item) -> Acc,
|
||||
{
|
||||
let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
|
||||
// Safety:
|
||||
// - `self.head` and `self.tail` in a ring buffer are always valid indices.
|
||||
// - `RingSlices::ring_slices` guarantees that the slices split according to `self.head` and `self.tail` are initialized.
|
||||
unsafe {
|
||||
let (front, back) = RingSlices::ring_slices(self.ring(), self.head, self.tail);
|
||||
accum = MaybeUninit::slice_assume_init_ref(front).iter().fold(accum, &mut f);
|
||||
MaybeUninit::slice_assume_init_ref(back).iter().fold(accum, &mut f)
|
||||
}
|
||||
@ -94,12 +111,13 @@ impl<'a, T> Iterator for Iter<'a, T> {
|
||||
let (mut iter, final_res);
|
||||
if self.tail <= self.head {
|
||||
// Safety: single slice self.ring[self.tail..self.head] is initialized.
|
||||
iter = unsafe { MaybeUninit::slice_assume_init_ref(&self.ring[self.tail..self.head]) }
|
||||
.iter();
|
||||
iter =
|
||||
unsafe { MaybeUninit::slice_assume_init_ref(&self.ring()[self.tail..self.head]) }
|
||||
.iter();
|
||||
final_res = iter.try_fold(init, &mut f);
|
||||
} else {
|
||||
// Safety: two slices: self.ring[self.tail..], self.ring[..self.head] both are initialized.
|
||||
let (front, back) = self.ring.split_at(self.tail);
|
||||
// Safety: two slices: self.ring()[self.tail..], self.ring()[..self.head] both are initialized.
|
||||
let (front, back) = unsafe { self.ring().split_at(self.tail) };
|
||||
|
||||
let mut back_iter = unsafe { MaybeUninit::slice_assume_init_ref(back).iter() };
|
||||
let res = back_iter.try_fold(init, &mut f);
|
||||
@ -133,7 +151,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
|
||||
// that is in bounds.
|
||||
unsafe {
|
||||
let idx = wrap_index(self.tail.wrapping_add(idx), self.ring.len());
|
||||
self.ring.get_unchecked(idx).assume_init_ref()
|
||||
self.ring().get_unchecked(idx).assume_init_ref()
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -149,18 +167,18 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
|
||||
// Safety:
|
||||
// - `self.head` in a ring buffer is always a valid index.
|
||||
// - `self.head` and `self.tail` equality is checked above.
|
||||
unsafe { Some(self.ring.get_unchecked(self.head).assume_init_ref()) }
|
||||
unsafe { Some(self.ring().get_unchecked(self.head).assume_init_ref()) }
|
||||
}
|
||||
|
||||
fn rfold<Acc, F>(self, mut accum: Acc, mut f: F) -> Acc
|
||||
where
|
||||
F: FnMut(Acc, Self::Item) -> Acc,
|
||||
{
|
||||
let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
|
||||
// Safety:
|
||||
// - `self.head` and `self.tail` in a ring buffer are always valid indices.
|
||||
// - `RingSlices::ring_slices` guarantees that the slices split according to `self.head` and `self.tail` are initialized.
|
||||
unsafe {
|
||||
let (front, back) = RingSlices::ring_slices(self.ring(), self.head, self.tail);
|
||||
accum = MaybeUninit::slice_assume_init_ref(back).iter().rfold(accum, &mut f);
|
||||
MaybeUninit::slice_assume_init_ref(front).iter().rfold(accum, &mut f)
|
||||
}
|
||||
@ -174,14 +192,14 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
|
||||
{
|
||||
let (mut iter, final_res);
|
||||
if self.tail <= self.head {
|
||||
// Safety: single slice self.ring[self.tail..self.head] is initialized.
|
||||
// Safety: single slice self.ring()[self.tail..self.head] is initialized.
|
||||
iter = unsafe {
|
||||
MaybeUninit::slice_assume_init_ref(&self.ring[self.tail..self.head]).iter()
|
||||
MaybeUninit::slice_assume_init_ref(&self.ring()[self.tail..self.head]).iter()
|
||||
};
|
||||
final_res = iter.try_rfold(init, &mut f);
|
||||
} else {
|
||||
// Safety: two slices: self.ring[self.tail..], self.ring[..self.head] both are initialized.
|
||||
let (front, back) = self.ring.split_at(self.tail);
|
||||
// Safety: two slices: self.ring()[self.tail..], self.ring()[..self.head] both are initialized.
|
||||
let (front, back) = unsafe { self.ring().split_at(self.tail) };
|
||||
|
||||
let mut front_iter =
|
||||
unsafe { MaybeUninit::slice_assume_init_ref(&front[..self.head]).iter() };
|
||||
|
Loading…
Reference in New Issue
Block a user