1 //! This module contains the parallel iterator types for double-ended queues 2 //! (`VecDeque<T>`). You will rarely need to interact with it directly 3 //! unless you have need to name one of the iterator types. 4 5 use std::collections::VecDeque; 6 7 use crate::iter::plumbing::*; 8 use crate::iter::*; 9 10 use crate::slice; 11 use crate::vec; 12 13 /// Parallel iterator over a double-ended queue 14 #[derive(Debug, Clone)] 15 pub struct IntoIter<T: Send> { 16 inner: vec::IntoIter<T>, 17 } 18 19 into_par_vec! { 20 VecDeque<T> => IntoIter<T>, 21 impl<T: Send> 22 } 23 24 delegate_indexed_iterator! { 25 IntoIter<T> => T, 26 impl<T: Send> 27 } 28 29 /// Parallel iterator over an immutable reference to a double-ended queue 30 #[derive(Debug)] 31 pub struct Iter<'a, T: Sync> { 32 inner: Chain<slice::Iter<'a, T>, slice::Iter<'a, T>>, 33 } 34 35 impl<'a, T: Sync> Clone for Iter<'a, T> { clone(&self) -> Self36 fn clone(&self) -> Self { 37 Iter { 38 inner: self.inner.clone(), 39 } 40 } 41 } 42 43 impl<'a, T: Sync> IntoParallelIterator for &'a VecDeque<T> { 44 type Item = &'a T; 45 type Iter = Iter<'a, T>; 46 into_par_iter(self) -> Self::Iter47 fn into_par_iter(self) -> Self::Iter { 48 let (a, b) = self.as_slices(); 49 Iter { 50 inner: a.into_par_iter().chain(b), 51 } 52 } 53 } 54 55 delegate_indexed_iterator! { 56 Iter<'a, T> => &'a T, 57 impl<'a, T: Sync + 'a> 58 } 59 60 /// Parallel iterator over a mutable reference to a double-ended queue 61 #[derive(Debug)] 62 pub struct IterMut<'a, T: Send> { 63 inner: Chain<slice::IterMut<'a, T>, slice::IterMut<'a, T>>, 64 } 65 66 impl<'a, T: Send> IntoParallelIterator for &'a mut VecDeque<T> { 67 type Item = &'a mut T; 68 type Iter = IterMut<'a, T>; 69 into_par_iter(self) -> Self::Iter70 fn into_par_iter(self) -> Self::Iter { 71 let (a, b) = self.as_mut_slices(); 72 IterMut { 73 inner: a.into_par_iter().chain(b), 74 } 75 } 76 } 77 78 delegate_indexed_iterator! { 79 IterMut<'a, T> => &'a mut T, 80 impl<'a, T: Send + 'a> 81 } 82