pddl-parser 0.2.3

A Rust library for parsing PDDL files
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
95
96
97
98

use nom::combinator::{map, opt};
use nom::sequence::{delimited, preceded, tuple};
use nom::IResult;
use serde::{Deserialize, Serialize};

use super::expression::Expression;
use super::typed_parameter::TypedParameter;
use crate::error::ParserError;
use crate::lexer::{Token, TokenStream};
use crate::tokens::id;

/// An action with typed parameters.
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DurativeAction {
    /// The name of the action.
    pub name: String,
    /// The parameters of the action.
    #[serde(default)]
    pub parameters: Vec<TypedParameter>,
    /// The duration of the action.
    pub duration: Expression,
    /// The condition of the action.
    pub condition: Option<Expression>,
    /// The effect of the action.
    pub effect: Expression,
}

impl DurativeAction {
    /// Parse a list of actions from a token stream.
    pub fn parse(input: TokenStream) -> IResult<TokenStream, DurativeAction, ParserError> {
        log::debug!("BEGIN > parse_durative_action {:?}", input.span());
        log::debug!("Parsing action: {:?}", input.peek_n(10));
        let (output, action) = map(
            delimited(
                Token::OpenParen,
                preceded(
                    Token::DurativeAction,
                    tuple((
                        id,
                        preceded(
                            Token::Parameters,
                            delimited(
                                Token::OpenParen,
                                TypedParameter::parse_typed_parameters,
                                Token::CloseParen,
                            ),
                        ),
                        preceded(Token::Duration, Expression::parse_expression),
                        opt(preceded(Token::Condition, Expression::parse_expression)),
                        preceded(Token::Effect, Expression::parse_expression),
                    )),
                ),
                Token::CloseParen,
            ),
            |(name, parameters, duration, condition, effect)| DurativeAction {
                name,
                parameters,
                duration,
                condition,
                effect,
            },
        )(input)?;
        log::debug!("END < parse_action {:?}", output.span());
        Ok((output, action))
    }

    /// Convert the action to PDDL.
    pub fn to_pddl(&self) -> String {
        let mut pddl = String::new();

        // Action name
        pddl.push_str(&format!("(:durative-action {}\n", self.name));

        // Parameters
        pddl.push_str(&format!(
            ":parameters ({})\n",
            self.parameters
                .iter()
                .map(TypedParameter::to_pddl)
                .collect::<Vec<_>>()
                .join(" ")
        ));

        // Duration
        pddl.push_str(&format!(":duration {}\n", self.duration.to_pddl()));

        // Condition
        if let Some(condition) = &self.condition {
            pddl.push_str(&format!(":condition {}\n", condition.to_pddl()));
        }

        // Effect
        pddl.push_str(&format!(":effect \n{}\n", self.effect.to_pddl()));

        pddl.push(')');
        pddl
    }
}