streaming.rs

// Design copied from emk's Rust Streaming (github.com/emk/rust-streaming)
use std::cell::Cell;

pub struct StreamingView<'a, T> {
        cur: Cell<usize>,
        limit: usize, 
        reference: &'a[T]
    }

    #[macro_export]
    macro_rules! streaming_for {
        ($var:pat in $expr:expr, $b:stmt) => {
            let ref iter = & $expr; 
            loop {
                match iter.next() {
                    None => {break;}
                    Some($var) => {$b}
                }
            }
        };
    }

    #[macro_export]
    macro_rules! streaming_fold {
        ($vector:expr, $base:expr, $inj_func:expr) => {{
            let iter = $vector; 
            let mut our_base = $base;
            loop {
                match iter.next() {
                    None => {break;}
                    Some(val) => {
                        our_base = $inj_func(our_base, val);   
                }
            }
        }
        our_base
        }};
    }

    pub trait StreamingIterator<'a, T: 'a> 
    where T: std::default::Default {
        fn next(&'a self) -> Option<&T>;
        fn fold<F>(&'a self, prov_base: &'a T, func: F) -> &T
        where F: Fn(&'a T, &'a T) -> &'a T,
        F: std::marker::Copy;
    }

    impl<'a, T> StreamingView<'a, T> {
        pub fn new(reference_vector: &'a [T]) -> StreamingView<'a, T>{
            StreamingView {
                cur : Cell::new(0usize), 
                limit: reference_vector.len(), 
                reference : reference_vector
            }
        }
    }

    impl<'b, T> StreamingIterator<'b, T> for StreamingView<'b, T> 
    where T: std::default::Default  {
        fn next(&'b self) -> Option<&'b T> {
            if self.cur.get() >= self.limit {
                None
            } else {
                let res = &self.reference[self.cur.get()];
                self.cur.set(self.cur.get() + 1); 
                return Some(&res)
            }
        }

        fn fold<F>(&'b self, prov_base: &'b T, func: F) -> &T 
        where F: Fn(&'b T, &'b T) -> &'b T,
        F: std::marker::Copy {
                match self.next() {
                    None => {return prov_base}, 
                    Some(val) => {
                        val //self.fold(func(val, prov_base), func)
                    }
            }
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn data_sketching_for(){
            let ref_vec : Vec<i32> = (0i32..9i32).into_iter().collect::<Vec<i32>>();
            let init_SV = StreamingView::new(&ref_vec);
            let mut base = 0;
            streaming_for!(x in init_SV,
                {base = base + x;});
            assert_eq!(36, base); 
        }

        #[test]
        fn data_sketching_fold(){
            let ref_vec : Vec<i32> = (0i32..9i32).into_iter().collect::<Vec<i32>>();
            let init_SV = StreamingView::new(&ref_vec);
            assert_eq!(36,streaming_fold!(init_SV, 0, |x, y| x + y));
        }
        #[test]
        fn data_sketching_fold_in_member_func(){
            
            let ref_vec : Vec<usize> = (0usize..9usize).into_iter().collect::<Vec<usize>>();
            let init_SV = StreamingView::new(&ref_vec);
            assert_eq!(&36_usize,init_SV.fold(&0_usize, |x : &usize, y: &usize| x + y));
        }   
    }