rune_alloc/vec_deque/
iter_mut.rs

Help
1use core::fmt;
2use core::iter::FusedIterator;
3use core::mem;
4use core::slice;
5
6/// A mutable iterator over the elements of a `VecDeque`.
7///
8/// This `struct` is created by the [`iter_mut`] method on [`super::VecDeque`]. See its
9/// documentation for more.
10///
11/// [`iter_mut`]: super::VecDeque::iter_mut
12pub struct IterMut<'a, T: 'a> {
13    i1: slice::IterMut<'a, T>,
14    i2: slice::IterMut<'a, T>,
15}
16
17impl<'a, T> IterMut<'a, T> {
18    pub(super) fn new(i1: slice::IterMut<'a, T>, i2: slice::IterMut<'a, T>) -> Self {
19        Self { i1, i2 }
20    }
21}
22
23impl<T: fmt::Debug> fmt::Debug for IterMut<'_, T> {
24    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
25        f.debug_tuple("IterMut")
26            .field(&self.i1.as_slice())
27            .field(&self.i2.as_slice())
28            .finish()
29    }
30}
31
32impl<'a, T> Iterator for IterMut<'a, T> {
33    type Item = &'a mut T;
34
35    #[inline]
36    fn next(&mut self) -> Option<&'a mut T> {
37        match self.i1.next() {
38            Some(val) => Some(val),
39            None => {
40                // most of the time, the iterator will either always
41                // call next(), or always call next_back(). By swapping
42                // the iterators once the first one is empty, we ensure
43                // that the first branch is taken as often as possible,
44                // without sacrificing correctness, as i1 is empty anyways
45                mem::swap(&mut self.i1, &mut self.i2);
46                self.i1.next()
47            }
48        }
49    }
50
51    #[inline]
52    fn size_hint(&self) -> (usize, Option<usize>) {
53        let len = self.len();
54        (len, Some(len))
55    }
56
57    fn fold<Acc, F>(self, accum: Acc, mut f: F) -> Acc
58    where
59        F: FnMut(Acc, Self::Item) -> Acc,
60    {
61        let accum = self.i1.fold(accum, &mut f);
62        self.i2.fold(accum, &mut f)
63    }
64
65    #[inline]
66    fn last(mut self) -> Option<&'a mut T> {
67        self.next_back()
68    }
69}
70
71impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
72    #[inline]
73    fn next_back(&mut self) -> Option<&'a mut T> {
74        match self.i2.next_back() {
75            Some(val) => Some(val),
76            None => {
77                // most of the time, the iterator will either always
78                // call next(), or always call next_back(). By swapping
79                // the iterators once the first one is empty, we ensure
80                // that the first branch is taken as often as possible,
81                // without sacrificing correctness, as i2 is empty anyways
82                mem::swap(&mut self.i1, &mut self.i2);
83                self.i2.next_back()
84            }
85        }
86    }
87
88    fn rfold<Acc, F>(self, accum: Acc, mut f: F) -> Acc
89    where
90        F: FnMut(Acc, Self::Item) -> Acc,
91    {
92        let accum = self.i2.rfold(accum, &mut f);
93        self.i1.rfold(accum, &mut f)
94    }
95}
96
97impl<T> ExactSizeIterator for IterMut<'_, T> {
98    fn len(&self) -> usize {
99        self.i1.len() + self.i2.len()
100    }
101}
102
103impl<T> FusedIterator for IterMut<'_, T> {}
rune_alloc/vec_deque/iter_mut.rs

rune_alloc/vec_deque/
iter_mut.rs
