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

mod fact;
mod goal;
mod init;
mod name;
mod objects;
mod token;

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

/// Represents a PDDL problem
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Problem<'a> {
    /// Name of the problem
    pub name: Option<&'a str>,
    /// Name of associated domain
    pub domain: Option<&'a str>,
    /// The objects consisting of name and type
    pub objects: Option<Vec<Object<'a>>>,
    /// List of initial state facts
    pub init: Option<Vec<Fact<'a>>>,
    /// List of goal state facts
    pub goal: Option<Goal<'a>>,
}

/// Denotes an object
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Object<'a> {
    pub name: &'a str,
    pub type_name: Option<&'a str>,
}

/// Denotes a goal condition
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Goal<'a> {
    Fact(Fact<'a>),
    And(Vec<Goal<'a>>),
    Or(Vec<Goal<'a>>),
    Not(Box<Goal<'a>>),
}

/// Denotes a fact of either init and goal
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Fact<'a> {
    pub predicate: &'a str,
    pub objects: Vec<&'a str>,
}

pub fn parse<'a>(input: &'a str) -> Result<Problem<'a>> {
    let mut name = None;
    let mut domain = None;
    let mut objects = None;
    let mut init = None;
    let mut goal = None;

    let mut lexer = Token::lexer(input);
    while let Some(token) = lexer.next() {
        match token {
            Ok(Token::ProblemName) => name = Some(name::parse(&mut lexer)?),
            Ok(Token::DomainName) => domain = Some(name::parse(&mut lexer)?),
            Ok(Token::Objects) => objects = Some(objects::parse(&mut lexer)?),
            Ok(Token::Init) => init = Some(init::parse(&mut lexer)?),
            Ok(Token::Goal) => goal = Some(goal::parse(&mut lexer)?),
            Ok(_) => continue,
            Err(_) => return Err(("invalid token", lexer.span())),
        }
    }

    Ok(Problem {
        name,
        domain,
        objects,
        init,
        goal,
    })
}