Trait BidirIterator

pub trait BidirIterator {
    type Item;

    // Required methods
    fn next(&mut self) -> Option<Self::Item>;
    fn prev(&mut self) -> Option<Self::Item>;

    // Provided methods
    fn forward(&mut self) -> Forward<&mut Self> 
       where Self: Sized { ... }
    fn forward_owned(self) -> Forward<Self> 
       where Self: Sized { ... }
    fn backward(&mut self) -> Backward<&mut Self> 
       where Self: Sized { ... }
    fn backward_owned(self) -> Backward<Self> 
       where Self: Sized { ... }
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
       where Self: Sized,
             P: FnMut(&Self::Item) -> bool { ... }
    fn map<B, F>(self, f: F) -> Map<Self, F>
       where Self: Sized,
             F: FnMut(Self::Item) -> B { ... }
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
       where Self: Sized,
             F: FnMut(Self::Item) -> Option<B> { ... }
}

Required Associated Types

type Item

Required Methods

fn next(&mut self) -> Option<Self::Item>

fn prev(&mut self) -> Option<Self::Item>

Examples

use bidir_iter::*;

let a: &[i64] = &[1, 2, 3];
let mut iter = a.bidir_iter();

assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&3));
assert_eq!(iter.next(), None);
assert_eq!(iter.prev(), Some(&3));
assert_eq!(iter.prev(), Some(&2));
assert_eq!(iter.prev(), Some(&1));
assert_eq!(iter.prev(), None);
assert_eq!(iter.next(), Some(&1));

Provided Methods

fn forward(&mut self) -> Forward<&mut Self>

where Self: Sized,

Create a forward-moving Iterator, starting at the current position. The forward iterator borrows the underlying bidirectional iterator.

Examples

use bidir_iter::*;

let a: &[i64] = &[1, 2, 3, 4];
let mut iter = a.bidir_iter();
let mut sum = 0;
for i in iter.forward() {
    sum += i;
}
assert_eq!(sum, 10);

for i in iter.backward() {
    sum += i;
}
assert_eq!(sum, 20);

fn forward_owned(self) -> Forward<Self>

where Self: Sized,

Create a forward-moving Iterator, starting at the current position. Like forward(), but the resulting iterator owns the underlying bidirectional iterator.

Examples

use bidir_iter::*;

let a: &[i64] = &[1, 2, 3, 4];

let mut iter = a.bidir_iter().forward_owned();
let mut sum = 0;
for i in iter {
    sum += i;
}
assert_eq!(sum, 10);

fn backward(&mut self) -> Backward<&mut Self>

where Self: Sized,

Create a backward-moving Iterator, starting at the current position.

fn backward_owned(self) -> Backward<Self>

where Self: Sized,

Create a backward-moving Iterator, starting at the current position. The resulting iterator owns the underlying bidir iterator.

Examples

use bidir_iter::*;

let a: &[i64] = &[1, 2, 3, 4];
let mut iter = a.bidir_iter();
// .forward() and .backward() borrow the bidir iter
assert_eq!(iter.forward().count(), 4);
let mut b = iter.backward_owned();
// iter has been moved into b
assert_eq!(b.count(), 4);

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Examples

use bidir_iter::*;

let a: &[i64] = &[1, 2, 3, 4, 5, 6, 7];
let mut iter = a.bidir_iter().filter(|n| *n % 2 == 0);

assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&4));
assert_eq!(iter.next(), Some(&6));
assert_eq!(iter.next(), None);
assert_eq!(iter.prev(), Some(&6));
assert_eq!(iter.prev(), Some(&4));
assert_eq!(iter.prev(), Some(&2));
assert_eq!(iter.prev(), None);

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Examples

use bidir_iter::*;

let a: &[i64] = &[1, 2, 3];
let mut iter = a.bidir_iter().map(|n| *n * 10);

assert_eq!(iter.next(), Some(10));
assert_eq!(iter.next(), Some(20));
assert_eq!(iter.next(), Some(30));
assert_eq!(iter.next(), None);
assert_eq!(iter.prev(), Some(30));

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Examples

use bidir_iter::*;

let a: &[i64] = &[0, 1, 2, 0, 3];
let mut iter = a.bidir_iter().filter_map(|i| if *i == 0 { None } else { Some(1 / i) });

assert_eq!(iter.next(), Some(1/1));
assert_eq!(iter.next(), Some(1/2));
assert_eq!(iter.next(), Some(1/3));
assert_eq!(iter.next(), None);

Implementations on Foreign Types

impl<T> BidirIterator for &mut T

where T: BidirIterator,

type Item = <T as BidirIterator>::Item

fn next(&mut self) -> Option<Self::Item>

fn prev(&mut self) -> Option<Self::Item>

Implementors

impl<'a, T> BidirIterator for BiIter<'a, T>

type Item = &'a T

impl<B, I: BidirIterator, F> BidirIterator for FilterMap<I, F>

where F: FnMut(I::Item) -> Option<B>,

type Item = B

impl<B, I: BidirIterator, F> BidirIterator for Map<I, F>

where F: FnMut(I::Item) -> B,

type Item = B

impl<B: BidirIterator, P> BidirIterator for Filter<B, P>

where P: FnMut(&B::Item) -> bool,

type Item = <B as BidirIterator>::Item