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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

pub mod action;
mod name;
mod parameters;
mod predicates;
mod requirements;
mod token;
mod types;

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

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Domain<'a> {
    pub name: Option<&'a str>,
    pub requirements: Option<Vec<&'a str>>,
    pub types: Option<Vec<Type<'a>>>,
    pub predicates: Option<Vec<Predicate<'a>>>,
    pub actions: Vec<Action<'a>>,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Type<'a> {
    pub name: &'a str,
    /// The parent of a the type
    pub parent: Option<&'a str>,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Predicate<'a> {
    pub name: &'a str,
    pub parameters: Vec<Parameter<'a>>,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Parameter<'a> {
    pub name: &'a str,
    pub r#type: Option<&'a str>,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Action<'a> {
    pub name: &'a str,
    pub parameters: Option<Vec<Parameter<'a>>>,
    pub precondition: Option<Expression<'a>>,
    pub effect: Expression<'a>,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Expression<'a> {
    Fact {
        predicate: &'a str,
        parameters: Vec<&'a str>,
    },
    Equal(Vec<Expression<'a>>),
    And(Vec<Expression<'a>>),
    Or(Vec<Expression<'a>>),
    Not(Box<Expression<'a>>),
}

pub fn parse<'a>(input: &'a str) -> Result<Domain<'a>> {
    let mut name = None;
    let mut requirements = None;
    let mut types = None;
    let mut predicates = None;
    let mut actions = Vec::new();

    let mut lexer = Token::lexer(input);
    while let Some(token) = lexer.next() {
        match token {
            Ok(Token::DomainName) => name = Some(name::parse(&mut lexer)?),
            Ok(Token::Requirements) => {
                requirements = Some(requirements::parse(&mut lexer)?)
            }
            Ok(Token::Types) => types = Some(types::parse(&mut lexer)?),
            Ok(Token::Predicates) => {
                predicates = Some(predicates::parse(&mut lexer)?)
            }
            Ok(Token::Action) => {
                actions.push(action::parse_stream(&mut lexer)?)
            }
            Ok(_) => continue,
            Err(_) => return Err(("invalid token", lexer.span())),
        }
    }

    Ok(Domain {
        name,
        requirements,
        types,
        predicates,
        actions,
    })
}