topdown-rs 0.3.3

use super::{CharSeq, ParserResult, Parser, Succ, Fail, Error};

pub struct Many<'a, T:'a> {
    parser: &'a (Parser<T>+'a)
}

pub fn many<'a, T>(p: &'a (Parser<T> + 'a)) -> Many<'a, T> {
    return Many{parser: p};
}

impl<'a, T> Parser<Vec<T>> for Many<'a, T> {
    #[allow(unused_variables)]
    fn _parse(&self, cs: &mut CharSeq) -> ParserResult<Vec<T>> {
        let mut succ = true;
        let mut r = Vec::new();
        while succ {
            match self.parser.parse(cs) {
                Succ(c) => r.push(c),
                Fail(m, l) => succ = false,
                Error(m, l) => return Error(m, l)
            }
        }
        return Succ(r);
    }
}


#[cfg(test)]
#[allow(unused_variables)]
#[allow(unused_imports)]
mod tests {
    use super::many;
    use super::super::{CharSeq, ParserResult, Parser, Succ, Fail, Error};

    #[test]
    fn test_many1() {
        let mut cs = CharSeq::new("aaabbbccc", "<mem>");
        assert!(cs.pos == 0);
        let s = "a";
        let m = many(&s);
        match cs.accept(&m) {
            Succ(a) => assert!(a == vec!["a", "a", "a"]),
            _ => assert!(false, "bug")
        }
        assert!(cs.pos == 3);
        assert!(cs.view() == "bbbccc");
    }

    #[test]
    fn test_many2() {
        let mut cs = CharSeq::new("aaabbbccc", "<mem>");
        assert!(cs.pos == 0);
        let s = "x";
        let m = many(&s);
        match cs.accept(&m) {
            Succ(a) => assert!(a.len() == 0),
            _ => assert!(false, "bug")
        }
        assert!(cs.pos == 0);
        assert!(cs.view() == "aaabbbccc");
    }
}