Enum Condition 

pub enum Condition {
    And(Vec<Condition>),
    Or(Vec<Condition>),
    Not(Box<Condition>),
    Imply(Box<Condition>, Box<Condition>),
    Forall {
        variables: TypedList<Variable>,
        condition: Box<Condition>,
    },
    Exists {
        variables: TypedList<Variable>,
        condition: Box<Condition>,
    },
    Predicate(AtomicFormula),
    Equals(Term, Term),
    NumericComparison {
        op: CompareOp,
        left: NumericExpr,
        right: NumericExpr,
    },
    Preference {
        name: Option<Name>,
        condition: Box<Condition>,
    },
    AtStart(Box<Condition>),
    AtEnd(Box<Condition>),
    OverAll(Box<Condition>),
    Always(Box<Condition>),
    Sometime(Box<Condition>),
    AtMostOnce(Box<Condition>),
    Within(f64, Box<Condition>),
    SometimeBefore(Box<Condition>, Box<Condition>),
    SometimeAfter(Box<Condition>, Box<Condition>),
    AlwaysWithin(f64, Box<Condition>, Box<Condition>),
    HoldDuring(f64, f64, Box<Condition>),
    HoldAfter(f64, Box<Condition>),
}

A condition (goal description) in PDDL.

This is the central recursive type for preconditions, goals, and constraint bodies. It covers logical connectives, first-order quantifiers, predicate tests, numeric comparisons, temporal wrappers (durative actions), PDDL3 trajectory constraints, and preferences.

Variants

And(Vec<Condition>)

Conjunction: (and c1 c2 ...).

Or(Vec<Condition>)

Disjunction: (or c1 c2 ...).

Not(Box<Condition>)

Negation: (not c).

Imply(Box<Condition>, Box<Condition>)

Implication: (imply c1 c2).

Forall

Universal quantification: (forall (?x - type) c).

Fields

variables: TypedList<Variable>

condition: Box<Condition>

Exists

Existential quantification: (exists (?x - type) c).

Fields

variables: TypedList<Variable>

condition: Box<Condition>

Predicate(AtomicFormula)

A positive predicate test: (at ?x ?y).

Equals(Term, Term)

Object equality: (= ?x ?y).

NumericComparison

Numeric comparison: (<op> <expr> <expr>).

Fields

op: CompareOp

left: NumericExpr

right: NumericExpr

Preference

PDDL3 named preference: (preference <name> <cond>).

Fields

name: Option<Name>

condition: Box<Condition>

AtStart(Box<Condition>)

(at start <cond>) – holds at the action’s start.

AtEnd(Box<Condition>)

(at end <cond>) – holds at the action’s end.

OverAll(Box<Condition>)

(over all <cond>) – holds throughout the action.

Always(Box<Condition>)

(always <cond>).

Sometime(Box<Condition>)

(sometime <cond>).

AtMostOnce(Box<Condition>)

(at-most-once <cond>).

Within(f64, Box<Condition>)

(within <deadline> <cond>).

SometimeBefore(Box<Condition>, Box<Condition>)

(sometime-before <cond1> <cond2>).

SometimeAfter(Box<Condition>, Box<Condition>)

(sometime-after <cond1> <cond2>).

AlwaysWithin(f64, Box<Condition>, Box<Condition>)

(always-within <window> <cond1> <cond2>).

HoldDuring(f64, f64, Box<Condition>)

(hold-during <t1> <t2> <cond>).

HoldAfter(f64, Box<Condition>)

(hold-after <t> <cond>).

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Condition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Condition

fn eq(&self, other: &Condition) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Condition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Condition