library/core/src/iter/adapters/rev.rs

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