[−][src]Struct peekmore::PeekMoreIterator
This iterator makes it possible to peek multiple times without consuming a value. In reality the underlying iterator will be consumed, but the values will be stored in a local queue. This queue allows us to move around unconsumed elements (as far as the iterator is concerned).
Methods
impl<I: Iterator> PeekMoreIterator<I>
[src]
pub fn peek(&mut self) -> Option<&I::Item>
[src]
Get a reference to the element where the cursor currently points at (if such element exists). Sometimes we also call this the current 'view'.
If we haven't advanced our cursor, that will be the same element as the one next()
would
return, but if we have moved our cursor, it will be the element we moved to instead.
Note that the cursor can't ever point at an element (which existed) before the first
unconsumed element within the iterator. In a sense the cursor moves independently within the
iterator. But it will always stick to unconsumed elements.
The following illustration aims to show how peek()
behaves. i
represents the position
of the iterator (i.e. the next value that will be returned if next()
is called) and j
represents the position of the cursor (i.e. the current element referenced if
peek()
is called).
In example code next to the illustrations, the first element 1
is analogous to A
,
2
to B
etc.
- start:
use peekmore::PeekMore; // Initialize our iterator. let iterable = [1, 2, 3, 4]; let mut iterator = iterable.iter().peekmore();
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
- call
peek()
:
let j = iterator.peek(); assert_eq!(j, Some(&&1));
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
returns Some(&A)
- call
advance_view()
let iter = iterator.move_next();
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^ ^
i j
- call
peek()
orpeek(); peek()
orpeek(); peek(); peek()
etc.
(The reference returned by peek()
will not change, similar to the behaviour of
core::iter::Peekable::peek
.
In order to move to the next peekable element, we need to advance our view.)
let j = iterator.peek(); assert_eq!(j, Some(&&2)); // Calling peek() multiple times doesn't shift the position of our cursor; // a reference to the same element will be returned each call. assert_eq!(iterator.peek(), Some(&&2)); assert_eq!(iterator.peek(), Some(&&2));
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^ ^
i j
returns Some(&B)
- call
next()
(i.e. advance the iterator; the element represented by A will be consumed)
let i = iterator.next(); assert_eq!(i, Some(&1));
----- ----- ----- -----
| A | | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
returns Some(A)
- call
next()
. (i.e. advance the iterator again; we'll see that the cursor position shifts to the next iterator position if the iterator consumes elements where our cursor pointed at previously (that is ifj < i
))
// Show that the cursor still points at the second element. let j = iterator.peek(); assert_eq!(j, Some(&&2)); // Consume the second element. let i = iterator.next(); assert_eq!(i, Some(&2)); // Our cursor previously pointed at the element represented by B. Since that element has // been consumed, the cursor shifts to the next unconsumed element: C. let j = iterator.peek(); assert_eq!(j, Some(&&3));
----- ----- ----- -----
| A | | B | | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
returns Some(B)
- Consume more elements by calling
next()
until we reachNone
:
let i = iterator.next(); assert_eq!(i, Some(&3)); let j = iterator.peek(); assert_eq!(j, Some(&&4)); let i = iterator.next(); assert_eq!(i, Some(&4)); let j = iterator.peek(); assert_eq!(j, None); let i = iterator.next(); assert_eq!(i, None);
pub fn peek_next(&mut self) -> Option<&I::Item>
[src]
Advance the cursor to the next element and return a reference to that value.
pub fn peek_previous(&mut self) -> Result<Option<&I::Item>, PeekMoreError>
[src]
Try to peek at a previous element. If no such element exists (i.e. our cursor is already
at the same point as the next iterator element), it will return an Err
result containing a
PeekMoreError::ElementHasBeenConsumed
.
If a previous element does exist, an option wrapped in an Ok
result will be returned.
Result
is re
pub fn peek_forward(&mut self, n: usize) -> Option<&I::Item>
[src]
Move the cursor n
steps forward and peek at the element the cursor then points to.
pub fn peek_backward(
&mut self,
n: usize
) -> Result<Option<&I::Item>, PeekMoreError>
[src]
&mut self,
n: usize
) -> Result<Option<&I::Item>, PeekMoreError>
Move the cursor n
steps backward and peek at the element the cursor then points to.
If there aren't n
elements prior to the element the cursor currently points at, a
PeekMoreError::ElementHasBeenConsumed
is returned instead.
The cursor will then stay at the position it was prior to calling this method.
If you want to peek at the first unconsumed element instead of returning with an error, you
can use the peek_backward_or_first
method instead of this one.
pub fn peek_backward_or_first(&mut self, n: usize) -> Option<&I::Item>
[src]
Move the cursor n
steps backward and peek at the element the cursor then points to, or
if there aren't n
elements prior to the element the cursor currently points to, peek at
the first unconsumed element instead.
ⓘImportant traits for PeekMoreIterator<I>pub fn move_next(&mut self) -> &mut PeekMoreIterator<I>
[src]
Move the cursor to the next peekable element.
This does not advance the iterator itself. To advance the iterator, use Iterator::next()
.
A mutable reference to the iterator is returned. This operation can be chained.
pub fn move_previous(
&mut self
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
[src]
&mut self
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
Move the cursor to the previous peekable element.
If such element doesn't exist, returns a PeekMoreError::ElementHasBeenConsumed
wrapped
in the Err
variant of Result
.
If we can move to a previous element, a mutable reference to the iterator,
wrapped in the Ok
variant of Result
will be returned.
ⓘImportant traits for PeekMoreIterator<I>pub fn move_forward(&mut self, n: usize) -> &mut PeekMoreIterator<I>
[src]
Move the cursor n
elements forward.
This does not advance the iterator itself. To advance the iterator, use Iterator::next()
.
pub fn move_backward(
&mut self,
n: usize
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
[src]
&mut self,
n: usize
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
Move the cursor n
elements backward. If there aren't n
unconsumed elements prior to the
cursor it will return an error. In case of an error, the cursor will stay at the position
it pointed at prior to calling this method.
If you want to reset the cursor to the first unconsumed element even if there aren't n
unconsumed elements before the position the cursor points at, you can use the
move_backward_or_reset
method instead.
ⓘImportant traits for PeekMoreIterator<I>pub fn move_backward_or_reset(&mut self, n: usize) -> &mut PeekMoreIterator<I>
[src]
Move the cursor n
elements backward or reset to the first non consumed element if
we can't move the cursor n
elements to the back.
pub fn reset_view(&mut self)
[src]
Reset the position of the cursor. If we call peek
just after a reset,
it will return a reference to the first element again.
Trait Implementations
impl<I: Debug + Iterator> Debug for PeekMoreIterator<I> where
I::Item: Debug,
[src]
I::Item: Debug,
impl<I: FusedIterator> FusedIterator for PeekMoreIterator<I>
[src]
Uses FusedIterator
default implementation.
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I>
[src]
type Item = I::Item
The type of the elements being iterated over.
fn next(&mut self) -> Option<Self::Item>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0[src]
fn count(self) -> usize
1.0.0[src]
fn last(self) -> Option<Self::Item>
1.0.0[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0[src]
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
fn peekable(self) -> Peekable<Self>
1.0.0[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
fn take(self, n: usize) -> Take<Self>
1.0.0[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self>
1.0.0[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self
1.0.0[src]
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
1.0.0[src]
B: FromIterator<Self::Item>,
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
1.0.0[src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
[src]
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]
F: FnMut(B, Self::Item) -> B,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
Self: DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
1.0.0[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
fn cycle(self) -> Cycle<Self> where
Self: Clone,
1.0.0[src]
Self: Clone,
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<I: ExactSizeIterator> ExactSizeIterator for PeekMoreIterator<I>
[src]
Uses ExactSizeIterator
default implementation.
impl<I: Clone + Iterator> Clone for PeekMoreIterator<I> where
I::Item: Clone,
[src]
I::Item: Clone,
ⓘImportant traits for PeekMoreIterator<I>fn clone(&self) -> PeekMoreIterator<I>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Auto Trait Implementations
impl<I> Unpin for PeekMoreIterator<I> where
I: Unpin,
<I as Iterator>::Item: Unpin,
I: Unpin,
<I as Iterator>::Item: Unpin,
impl<I> Send for PeekMoreIterator<I> where
I: Send,
<I as Iterator>::Item: Send,
I: Send,
<I as Iterator>::Item: Send,
impl<I> Sync for PeekMoreIterator<I> where
I: Sync,
<I as Iterator>::Item: Sync,
I: Sync,
<I as Iterator>::Item: Sync,
Blanket Implementations
impl<I> PeekMore for I where
I: Iterator,
[src]
I: Iterator,
ⓘImportant traits for PeekMoreIterator<I>fn peekmore(Self) -> PeekMoreIterator<I>
[src]
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.