Struct Plan 

pub struct Plan {
    pub steps: Vec<PlanStep>,
    pub cost: f64,
}

The output produced by a planner when search succeeds.

This is the structure wrapped by SearchOutcome::Plan.

Invariants

• steps is ordered: steps[0] is applied first.
• cost equals the sum of the applied operators’ cost values; it is not necessarily steps.len() because operator costs need not be unit.
• An empty plan (steps is empty, cost == 0.0) is a valid result when the initial state already satisfies the goal.

Examples

use miniplan::plan::{Plan, PlanStep};
use miniplan::task::OpId;

let plan = Plan::new();
assert!(plan.is_empty());
assert_eq!(plan.len(), 0);
assert_eq!(plan.cost, 0.0);

let mut plan = Plan::new();
plan.steps.push(PlanStep { op_id: OpId(0), op_name: "pick".into() });
plan.cost = 1.0;
assert!(!plan.is_empty());
assert_eq!(plan.len(), 1);

assert_eq!(
    plan.to_string(),
    "; cost = 1\n; length = 1\n(pick)\n"
);

Fields

steps: Vec<PlanStep>

Ordered list of PlanSteps; execute left-to-right.

cost: f64

Accumulated cost of the steps.

Must stay in sync with steps — callers mutate both together.

Implementations

impl Plan

pub fn new() -> Self

Create an empty plan.

The returned value satisfies steps.is_empty() and cost == 0.0. This is equivalent to Plan::default().

Examples

use miniplan::plan::Plan;

let plan = Plan::new();
assert!(plan.is_empty());
assert_eq!(plan.cost, 0.0);

pub fn is_empty(&self) -> bool

Returns true if the plan has no steps.

Examples

use miniplan::plan::Plan;

assert!(Plan::new().is_empty());

pub fn len(&self) -> usize

Returns the number of steps in the plan.

This counts steps, not cost.

Examples

use miniplan::plan::Plan;

assert_eq!(Plan::new().len(), 0);

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl Default for Plan

fn default() -> Self

Creates an empty plan with steps empty and cost set to 0.0.

Equivalent to Plan::new.

impl Display for Plan

Human-readable display format for a Plan.

Emits a PDDL-style plan file:

• Line 1: ; cost = <cost> (semicolons are PDDL plan comments).
• Line 2: ; length = <len>.
• Lines 3..: one (<op_name>) per step, each terminated by \n.

The trailing newline after the last step matches the writeln! macro.

Examples

use miniplan::plan::{Plan, PlanStep};
use miniplan::task::OpId;

let mut plan = Plan::new();
plan.steps.push(PlanStep { op_id: OpId(0), op_name: "pick".into() });
plan.steps.push(PlanStep { op_id: OpId(1), op_name: "place".into() });
plan.cost = 2.0;

assert_eq!(
    plan.to_string(),
    "; cost = 2\n; length = 2\n(pick)\n(place)\n"
);

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

Formats the value using the given formatter.

impl PartialEq for Plan

fn eq(&self, other: &Plan) -> 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 StructuralPartialEq for Plan