1 use crate::iter::{FusedIterator, TrustedLen};
2 use crate::ops::Try;
3 
4 /// A double-ended iterator with the direction inverted.
5 ///
6 /// This `struct` is created by the [`rev`] method on [`Iterator`]. See its
7 /// documentation for more.
8 ///
9 /// [`rev`]: Iterator::rev
10 /// [`Iterator`]: trait.Iterator.html
11 #[derive(Clone, Debug)]
12 #[must_use = "iterators are lazy and do nothing unless consumed"]
13 #[stable(feature = "rust1", since = "1.0.0")]
14 pub struct Rev<T> {
15     iter: T,
16 }
17 
18 impl<T> Rev<T> {
new(iter: T) -> Rev<T>19     pub(in crate::iter) fn new(iter: T) -> Rev<T> {
20         Rev { iter }
21     }
22 }
23 
24 #[stable(feature = "rust1", since = "1.0.0")]
25 impl<I> Iterator for Rev<I>
26 where
27     I: DoubleEndedIterator,
28 {
29     type Item = <I as Iterator>::Item;
30 
31     #[inline]
next(&mut self) -> Option<<I as Iterator>::Item>32     fn next(&mut self) -> Option<<I as Iterator>::Item> {
33         self.iter.next_back()
34     }
35     #[inline]
size_hint(&self) -> (usize, Option<usize>)36     fn size_hint(&self) -> (usize, Option<usize>) {
37         self.iter.size_hint()
38     }
39 
40     #[inline]
advance_by(&mut self, n: usize) -> Result<(), usize>41     fn advance_by(&mut self, n: usize) -> Result<(), usize> {
42         self.iter.advance_back_by(n)
43     }
44 
45     #[inline]
nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>46     fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item> {
47         self.iter.nth_back(n)
48     }
49 
try_fold<B, F, R>(&mut self, init: B, f: F) -> R where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,50     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
51     where
52         Self: Sized,
53         F: FnMut(B, Self::Item) -> R,
54         R: Try<Output = B>,
55     {
56         self.iter.try_rfold(init, f)
57     }
58 
fold<Acc, F>(self, init: Acc, f: F) -> Acc where F: FnMut(Acc, Self::Item) -> Acc,59     fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
60     where
61         F: FnMut(Acc, Self::Item) -> Acc,
62     {
63         self.iter.rfold(init, f)
64     }
65 
66     #[inline]
find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,67     fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
68     where
69         P: FnMut(&Self::Item) -> bool,
70     {
71         self.iter.rfind(predicate)
72     }
73 }
74 
75 #[stable(feature = "rust1", since = "1.0.0")]
76 impl<I> DoubleEndedIterator for Rev<I>
77 where
78     I: DoubleEndedIterator,
79 {
80     #[inline]
next_back(&mut self) -> Option<<I as Iterator>::Item>81     fn next_back(&mut self) -> Option<<I as Iterator>::Item> {
82         self.iter.next()
83     }
84 
85     #[inline]
advance_back_by(&mut self, n: usize) -> Result<(), usize>86     fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
87         self.iter.advance_by(n)
88     }
89 
90     #[inline]
nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>91     fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item> {
92         self.iter.nth(n)
93     }
94 
try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,95     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
96     where
97         Self: Sized,
98         F: FnMut(B, Self::Item) -> R,
99         R: Try<Output = B>,
100     {
101         self.iter.try_fold(init, f)
102     }
103 
rfold<Acc, F>(self, init: Acc, f: F) -> Acc where F: FnMut(Acc, Self::Item) -> Acc,104     fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
105     where
106         F: FnMut(Acc, Self::Item) -> Acc,
107     {
108         self.iter.fold(init, f)
109     }
110 
rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,111     fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
112     where
113         P: FnMut(&Self::Item) -> bool,
114     {
115         self.iter.find(predicate)
116     }
117 }
118 
119 #[stable(feature = "rust1", since = "1.0.0")]
120 impl<I> ExactSizeIterator for Rev<I>
121 where
122     I: ExactSizeIterator + DoubleEndedIterator,
123 {
len(&self) -> usize124     fn len(&self) -> usize {
125         self.iter.len()
126     }
127 
is_empty(&self) -> bool128     fn is_empty(&self) -> bool {
129         self.iter.is_empty()
130     }
131 }
132 
133 #[stable(feature = "fused", since = "1.26.0")]
134 impl<I> FusedIterator for Rev<I> where I: FusedIterator + DoubleEndedIterator {}
135 
136 #[unstable(feature = "trusted_len", issue = "37572")]
137 unsafe impl<I> TrustedLen for Rev<I> where I: TrustedLen + DoubleEndedIterator {}
138