pddlp 0.1.7

A PDDL Parser
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
40
41
42
43
44
45
46
47
48
49
50

mod step;
mod token;

use self::token::Token;
use crate::Result;
use logos::Logos;

/// Denotes a single step in a plan
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Step<'a> {
    pub action: &'a str,
    pub objects: Vec<&'a str>,
}

/// A plan denotes a sequence of steps
/// Which is the solution to planning task
pub type Plan<'a> = Vec<Step<'a>>;

/// Tries parsing input as a pddl plan
/// In case of error, returns Err with error msg
pub fn parse(input: &str) -> Result<Plan> {
    let mut lexer = Token::lexer(input);

    let mut steps = vec![];
    while let Some(token) = lexer.next() {
        match token {
            Ok(Token::LParen) => steps.push(step::parse(&mut lexer)?),
            Ok(_) => return Err(("Unexpected Token", lexer.span())),
            Err(_) => return Err(("Invalid Token", lexer.span())),
        }
    }

    Ok(steps)
}

#[cfg(test)]
mod test {
    use super::{Plan, Result, Step};
    use rstest::rstest;

    #[rstest]
    #[case("(a)", Ok(vec![crate::plan::Step { action: "a", objects: vec![] }]))]
    #[case("(a)(b)", Ok(vec![
        Step { action: "a", objects: vec![] },
        Step { action: "b", objects: vec![] }]
    ))]
    fn parse(#[case] input: &str, #[case] expected: Result<Plan>) {
        assert_eq!(expected, super::parse(input));
    }
}