batcher.rs

pub struct Batcher<T> {
    iter: T,
    batch_size: usize,
    finished: bool
}

impl<T> Batcher<T> where T: Iterator {
    pub fn new(iter: T, batch_size: usize) -> Batcher<T>{
        Batcher{
            iter: iter,
            batch_size: batch_size,
            finished: false
        }
    }
}

impl<T> Iterator for Batcher<T> where T: Iterator {
    type Item = Vec<T::Item>;

    fn next(&mut self) -> Option<Vec<T::Item>> {
        if !self.finished {
            let mut buffer = vec![];
            let mut retreived = 0;
            while retreived < self.batch_size {
                match self.iter.next() {
                    Some(val) => {
                        buffer.push(val);
                        retreived += 1;
                    },
                    None => {
                        self.finished = true;
                        break;
                    }
                }
            }
            Some(buffer)
        } else {
            None
        }
    }
}