[−][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).
Implementations
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_cursor()
let iter = iterator.advance_cursor();
----- ----- ----- -----
| 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.
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.
pub fn peek_nth(&mut self, n: usize) -> Option<&I::Item>
[src]
Peek at the nth element without moving the cursor.
pub fn advance_cursor(&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 advance_cursor_by(&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 advance_cursor_while<P: Fn(Option<&I::Item>) -> bool>(
&mut self,
predicate: P
) -> &mut PeekMoreIterator<I>
[src]
&mut self,
predicate: P
) -> &mut PeekMoreIterator<I>
Moves the cursor forward for as many elements as a predicate is true.
pub fn move_cursor_back(
&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 an element doesn't exist, returns a PeekMoreError::ElementHasBeenConsumed
.
If we can move to a previous element, a mutable reference to the iterator,
wrapped in the Ok
variant of Result
will be returned.
pub fn move_cursor_back_by(
&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.
pub fn move_cursor_back_or_reset(
&mut self,
n: usize
) -> &mut PeekMoreIterator<I>
[src]
&mut self,
n: usize
) -> &mut PeekMoreIterator<I>
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 move_nth(&mut self, n: usize) -> &mut PeekMoreIterator<I>
[src]
Move the cursor to the n-th element of the queue.
pub fn reset_view(&mut self)
[src]
Deprecated: use reset_cursor
instead.
pub fn reset_cursor(&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: Clone + Iterator> Clone for PeekMoreIterator<I> where
I::Item: Clone,
[src]
I::Item: Clone,
fn clone(&self) -> PeekMoreIterator<I>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<I: Debug + Iterator> Debug for PeekMoreIterator<I> where
I::Item: Debug,
[src]
I::Item: Debug,
impl<I: ExactSizeIterator> ExactSizeIterator for PeekMoreIterator<I>
[src]
Uses ExactSizeIterator
default implementation.
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 map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
P: FnMut(Self::Item) -> Option<B>,
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 fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
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 try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
[src]
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
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>,
Auto Trait Implementations
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,
impl<I> Unpin for PeekMoreIterator<I> where
I: Unpin,
<I as Iterator>::Item: Unpin,
I: Unpin,
<I as Iterator>::Item: Unpin,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
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> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
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<I> PeekMore for I where
I: Iterator,
[src]
I: Iterator,
fn peekmore(Self) -> PeekMoreIterator<I>
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut 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> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,