New upstream version 1.51.0+dfsg1

[rustc.git] / vendor / generic-array-0.12.3 / src / iter.rs

//! `GenericArray` iterator implementation.\r
\r
use super::{ArrayLength, GenericArray};\r
use core::{cmp, ptr, fmt, mem};\r
use core::mem::ManuallyDrop;\r
\r
/// An iterator that moves out of a `GenericArray`\r
pub struct GenericArrayIter<T, N: ArrayLength<T>> {\r
    // Invariants: index <= index_back <= N\r
    // Only values in array[index..index_back] are alive at any given time.\r
    // Values from array[..index] and array[index_back..] are already moved/dropped.\r
    array: ManuallyDrop<GenericArray<T, N>>,\r
    index: usize,\r
    index_back: usize,\r
}\r
\r
#[cfg(test)]\r
mod test {\r
    use super::*;\r
\r
    fn send<I: Send>(_iter: I) {}\r
\r
    #[test]\r
    fn test_send_iter() {\r
        send(GenericArray::from([1, 2, 3, 4]).into_iter());\r
    }\r
}\r
\r
impl<T, N> GenericArrayIter<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    /// Returns the remaining items of this iterator as a slice\r
    #[inline]\r
    pub fn as_slice(&self) -> &[T] {\r
        &self.array.as_slice()[self.index..self.index_back]\r
    }\r
\r
    /// Returns the remaining items of this iterator as a mutable slice\r
    #[inline]\r
    pub fn as_mut_slice(&mut self) -> &mut [T] {\r
        &mut self.array.as_mut_slice()[self.index..self.index_back]\r
    }\r
}\r
\r
impl<T, N> IntoIterator for GenericArray<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    type Item = T;\r
    type IntoIter = GenericArrayIter<T, N>;\r
\r
    fn into_iter(self) -> Self::IntoIter {\r
        GenericArrayIter {\r
            array: ManuallyDrop::new(self),\r
            index: 0,\r
            index_back: N::to_usize(),\r
        }\r
    }\r
}\r
\r
// Based on work in rust-lang/rust#49000\r
impl<T: fmt::Debug, N> fmt::Debug for GenericArrayIter<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\r
        f.debug_tuple("GenericArrayIter")\r
            .field(&self.as_slice())\r
            .finish()\r
    }\r
}\r
\r
impl<T, N> Drop for GenericArrayIter<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    #[inline]\r
    fn drop(&mut self) {\r
        // Drop values that are still alive.\r
        for p in self.as_mut_slice() {\r
            unsafe {\r
                ptr::drop_in_place(p);\r
            }\r
        }\r
    }\r
}\r
\r
// Based on work in rust-lang/rust#49000\r
impl<T: Clone, N> Clone for GenericArrayIter<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    fn clone(&self) -> Self {\r
        // This places all cloned elements at the start of the new array iterator,\r
        // not at their original indices.\r
        unsafe {\r
            let mut iter = GenericArrayIter {\r
                array: ManuallyDrop::new(mem::uninitialized()),\r
                index: 0,\r
                index_back: 0,\r
            };\r
\r
            for (dst, src) in iter.array.iter_mut().zip(self.as_slice()) {\r
                ptr::write(dst, src.clone());\r
\r
                iter.index_back += 1;\r
            }\r
\r
            iter\r
        }\r
    }\r
}\r
\r
impl<T, N> Iterator for GenericArrayIter<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    type Item = T;\r
\r
    #[inline]\r
    fn next(&mut self) -> Option<T> {\r
        if self.index < self.index_back {\r
            let p = unsafe { Some(ptr::read(self.array.get_unchecked(self.index))) };\r
\r
            self.index += 1;\r
\r
            p\r
        } else {\r
            None\r
        }\r
    }\r
\r
    #[inline]\r
    fn size_hint(&self) -> (usize, Option<usize>) {\r
        let len = self.len();\r
        (len, Some(len))\r
    }\r
\r
    #[inline]\r
    fn count(self) -> usize {\r
        self.len()\r
    }\r
\r
    fn nth(&mut self, n: usize) -> Option<T> {\r
        // First consume values prior to the nth.\r
        let ndrop = cmp::min(n, self.len());\r
\r
        for p in &mut self.array[self.index..self.index + ndrop] {\r
            self.index += 1;\r
\r
            unsafe {\r
                ptr::drop_in_place(p);\r
            }\r
        }\r
\r
        self.next()\r
    }\r
\r
    fn last(mut self) -> Option<T> {\r
        // Note, everything else will correctly drop first as `self` leaves scope.\r
        self.next_back()\r
    }\r
}\r
\r
impl<T, N> DoubleEndedIterator for GenericArrayIter<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    fn next_back(&mut self) -> Option<T> {\r
        if self.index < self.index_back {\r
            self.index_back -= 1;\r
\r
            unsafe { Some(ptr::read(self.array.get_unchecked(self.index_back))) }\r
        } else {\r
            None\r
        }\r
    }\r
}\r
\r
impl<T, N> ExactSizeIterator for GenericArrayIter<T, N>\r
where\r
    N: ArrayLength<T>,\r
{\r
    fn len(&self) -> usize {\r
        self.index_back - self.index\r
    }\r
}\r
\r
// TODO: Implement `FusedIterator` and `TrustedLen` when stabilized