topdown-rs 0.3.0

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

pub struct Cond<'a, S, T:Clone> {
    cond: &'a (Parser<S> + 'a),
    parser: &'a (Parser<T> + 'a),
    else_value: T
}

pub fn cond<'a, S, T:Clone>(c: &'a (Parser<S> + 'a), p: &'a (Parser<T> + 'a), e: T) -> Cond<'a, S, T> {
    return Cond{cond:c, parser:p, else_value: e};
}

impl<'a, S, T:Clone> Parser<T> for Cond<'a, S, T> {
    #[allow(unused_variables)]
    fn _parse(&self, cs: &mut CharSeq) -> ParserResult<T> {
        match cs.accept(self.cond) {
            Succ(r) => cs.accept(self.parser),
            Fail(m, l) => Succ(self.else_value.clone()),
            Error(m, l) => Error(m, l)
        }
    }
}


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

    #[test]
    fn test_cond1() {
        let mut cs = CharSeq::new("ab", "");
        let a = "a";
        let b = "b";
        let c = cond(&a, &b, "default".to_string());
        match cs.accept(&c) {
            Succ(r) => assert_eq!(r.as_slice(), "b"),
            _ => assert!(false)
        }
    }

    #[test]
    fn test_cond2() {
        let mut cs = CharSeq::new("bb", "");
        let a = "a";
        let b = "b";
        let c = cond(&a, &b, "default".to_string());
        match cs.accept(&c) {
            Succ(r) => assert_eq!(r.as_slice(), "default"),
            _ => assert!(false)
        }
    }

    #[test]
    fn test_cond3() {
        let mut cs = CharSeq::new("ax", "");
        let a = "a";
        let b = "b";
        let c = cond(&a, &b, "default".to_string());
        match cs.accept(&c) {
            Fail(m, l) => (),
            _ => assert!(false)
        }
    }
}