pddl 0.2.0

A PDDL 3.1 parser, strongly typed
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

//! Contains preference goal definitions.

use crate::types::{GoalDefinition, Preference};

/// A preferred goal definition.
///
/// ## Usage
/// Used by [`PreconditionGoalDefinition`](crate::PreconditionGoalDefinition).
#[derive(Debug, Clone, PartialEq)]
pub enum PreferenceGoalDefinition {
    Goal(GoalDefinition),
    /// ## Requirements
    /// Requires [Preferences](crate::Requirement::Preferences).
    Preference(Preference),
}

impl PreferenceGoalDefinition {
    pub const fn from_gd(gd: GoalDefinition) -> Self {
        Self::Goal(gd)
    }

    pub fn from_preference(pref: Preference) -> Self {
        Self::Preference(pref)
    }
}

impl From<GoalDefinition> for PreferenceGoalDefinition {
    fn from(value: GoalDefinition) -> Self {
        PreferenceGoalDefinition::from_gd(value)
    }
}

impl From<Preference> for PreferenceGoalDefinition {
    fn from(value: Preference) -> Self {
        PreferenceGoalDefinition::from_preference(value)
    }
}

/// Alias for [`PreferenceGoalDefinition`]; matches BNF `<pref-GD>`.
#[deprecated(since = "0.2.0", note = "Use `PreferenceGoalDefinition` instead")]
pub type PreferenceGD = PreferenceGoalDefinition;

#[cfg(test)]
mod tests {
    use super::*;
    use crate::GoalDefinition;

    #[test]
    fn from_gd() {
        let gd = GoalDefinition::and(Vec::new());
        let pref_gd = PreferenceGoalDefinition::from_gd(gd.clone());
        assert!(matches!(pref_gd, PreferenceGoalDefinition::Goal(_)));
    }

    #[test]
    fn from_preference() {
        let pref = crate::Preference::from(GoalDefinition::and(Vec::new()));
        let pref_gd = PreferenceGoalDefinition::from_preference(pref.clone());
        assert!(matches!(pref_gd, PreferenceGoalDefinition::Preference(_)));
    }

    #[test]
    fn from_gd_trait() {
        let gd = GoalDefinition::and(Vec::new());
        let pref_gd = PreferenceGoalDefinition::from(gd);
        assert!(matches!(pref_gd, PreferenceGoalDefinition::Goal(_)));
    }

    #[test]
    fn from_preference_trait() {
        let pref = crate::Preference::from(GoalDefinition::and(Vec::new()));
        let pref_gd = PreferenceGoalDefinition::from(pref);
        assert!(matches!(pref_gd, PreferenceGoalDefinition::Preference(_)));
    }

    #[test]
    fn clone_works() {
        let gd = GoalDefinition::and(Vec::new());
        let pref_gd = PreferenceGoalDefinition::from_gd(gd);
        let clone = pref_gd.clone();
        assert_eq!(pref_gd, clone);
    }

    #[test]
    fn debug_impl() {
        let gd = GoalDefinition::and(Vec::new());
        let pref_gd = PreferenceGoalDefinition::from_gd(gd);
        let dbg = format!("{pref_gd:?}");
        assert!(dbg.contains("Goal"));
    }

    #[test]
    #[allow(deprecated)]
    fn deprecated_alias_exists() {
        fn _assert_alias(_: PreferenceGD) {}
    }
}