differential-dataflow 0.0.3

An incremental data-parallel dataflow platform
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

use std::iter::Peekable;

pub trait Coalesce<I: Iterator> {
    fn coalesce(self) -> CoalesceIterator<I>;
}

impl<I: Iterator> Coalesce<I> for I {
    fn coalesce(self) -> CoalesceIterator<I> {
        CoalesceIterator::new(self)
    }
}

pub struct CoalesceIterator<I: Iterator> {
    iter: Peekable<I>,
}

impl<I: Iterator> CoalesceIterator<I> {
    pub fn new(iter: I) -> CoalesceIterator<I> {
        CoalesceIterator {
            iter: iter.peekable(),
        }
    }
}

impl<V: Ord, I: Iterator<Item=(V, i32)>> Iterator for CoalesceIterator<I> {
    type Item = (V, i32);
    #[inline]
    fn next(&mut self) -> Option<(V, i32)> {
        loop {
            if let Some((val, mut wgt)) = self.iter.next() {
                while self.iter.peek().map(|&(ref v, _)| v == &val) == Some(true) {
                    wgt += self.iter.next().unwrap().1;
                }
                if wgt != 0 { return Some((val, wgt)); }
            }
            else { return None; }
        }
    }
}