}
}
+impl<A, T: DoubleEndedIterator<A>, U: DoubleEndedIterator<A>> DoubleEndedIterator<A>
+for ChainIterator<A, T, U> {
+ #[inline]
+ fn next_back(&mut self) -> Option<A> {
+ match self.b.next_back() {
+ Some(x) => Some(x),
+ None => self.a.next_back()
+ }
+ }
+}
+
/// An iterator which iterates two other iterators simultaneously
// FIXME #6967: Dummy A & B parameters to get around type inference bug
pub struct ZipIterator<A, T, B, U> {
}
}
+impl<'self, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B>
+for MapIterator<'self, A, B, T> {
+ #[inline]
+ fn next_back(&mut self) -> Option<B> {
+ match self.iter.next_back() {
+ Some(a) => Some((self.f)(a)),
+ _ => None
+ }
+ }
+}
+
/// An iterator which filters the elements of `iter` with `predicate`
pub struct FilterIterator<'self, A, T> {
priv iter: T,
}
}
+impl<'self, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for FilterIterator<'self, A, T> {
+ #[inline]
+ fn next_back(&mut self) -> Option<A> {
+ loop {
+ match self.iter.next_back() {
+ None => return None,
+ Some(x) => {
+ if (self.predicate)(&x) {
+ return Some(x);
+ } else {
+ loop
+ }
+ }
+ }
+ }
+ }
+}
+
/// An iterator which uses `f` to both filter and map elements from `iter`
pub struct FilterMapIterator<'self, A, B, T> {
priv iter: T,
}
}
+impl<'self, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B>
+for FilterMapIterator<'self, A, B, T> {
+ #[inline]
+ fn next_back(&mut self) -> Option<B> {
+ loop {
+ match self.iter.next_back() {
+ None => return None,
+ Some(x) => {
+ match (self.f)(x) {
+ Some(y) => return Some(y),
+ None => ()
+ }
+ }
+ }
+ }
+ }
+}
+
/// An iterator which yields the current count and the element during iteration
// FIXME #6967: Dummy A parameter to get around type inference bug
pub struct EnumerateIterator<A, T> {
}
}
+impl<'self, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for PeekIterator<'self, A, T> {
+ #[inline]
+ fn next_back(&mut self) -> Option<A> {
+ let next = self.iter.next_back();
+
+ match next {
+ Some(ref a) => (self.f)(a),
+ None => ()
+ }
+
+ next
+ }
+}
+
/// An iterator which just modifies the contained state throughout iteration.
pub struct UnfoldrIterator<'self, A, St> {
priv f: &'self fn(&mut St) -> Option<A>,
it.next();
assert_eq!(it.invert().transform(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]);
}
+
+ #[test]
+ fn test_double_ended_map() {
+ let xs = [1, 2, 3, 4, 5, 6];
+ let mut it = xs.iter().transform(|&x| x * -1);
+ assert_eq!(it.next(), Some(-1));
+ assert_eq!(it.next(), Some(-2));
+ assert_eq!(it.next_back(), Some(-6));
+ assert_eq!(it.next_back(), Some(-5));
+ assert_eq!(it.next(), Some(-3));
+ assert_eq!(it.next_back(), Some(-4));
+ assert_eq!(it.next(), None);
+ }
+
+ #[test]
+ fn test_double_ended_filter() {
+ let xs = [1, 2, 3, 4, 5, 6];
+ let mut it = xs.iter().filter(|&x| *x & 1 == 0);
+ assert_eq!(it.next_back().unwrap(), &6);
+ assert_eq!(it.next_back().unwrap(), &4);
+ assert_eq!(it.next().unwrap(), &2);
+ assert_eq!(it.next_back(), None);
+ }
+
+ #[test]
+ fn test_double_ended_filter_map() {
+ let xs = [1, 2, 3, 4, 5, 6];
+ let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None });
+ assert_eq!(it.next_back().unwrap(), 12);
+ assert_eq!(it.next_back().unwrap(), 8);
+ assert_eq!(it.next().unwrap(), 4);
+ assert_eq!(it.next_back(), None);
+ }
+
+ #[test]
+ fn test_double_ended_chain() {
+ let xs = [1, 2, 3, 4, 5];
+ let ys = ~[7, 9, 11];
+ let mut it = xs.iter().chain_(ys.iter()).invert();
+ assert_eq!(it.next().unwrap(), &11)
+ assert_eq!(it.next().unwrap(), &9)
+ assert_eq!(it.next_back().unwrap(), &1)
+ assert_eq!(it.next_back().unwrap(), &2)
+ assert_eq!(it.next_back().unwrap(), &3)
+ assert_eq!(it.next_back().unwrap(), &4)
+ assert_eq!(it.next_back().unwrap(), &5)
+ assert_eq!(it.next_back().unwrap(), &7)
+ assert_eq!(it.next_back(), None)
+ }
}