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