Struct ExecutionPlan 

pub struct ExecutionPlan {
    pub spec_name: String,
    pub facts: IndexMap<FactPath, FactData>,
    pub rules: Vec<ExecutableRule>,
    pub sources: HashMap<String, String>,
    pub meta: HashMap<String, MetaValue>,
    pub valid_from: Option<DateTimeValue>,
    pub valid_to: Option<DateTimeValue>,
}

A complete execution plan ready for the evaluator

Contains the topologically sorted list of rules to execute, along with all facts. Self-contained structure - no spec lookups required during evaluation.

Fields

spec_name: String

Main spec name

facts: IndexMap<FactPath, FactData>

Per-fact data in definition order: value, type-only, or spec reference.

rules: Vec<ExecutableRule>

Rules to execute in topological order (sorted by dependencies)

sources: HashMap<String, String>

Source code for error messages

meta: HashMap<String, MetaValue>

Spec metadata

valid_from: Option<DateTimeValue>

Temporal slice start (inclusive). None = -∞.

valid_to: Option<DateTimeValue>

Temporal slice end (exclusive). None = +∞.

Implementations

impl ExecutionPlan

pub fn schema(&self) -> SpecSchema

Build a SpecSchema summarising all of this plan’s facts and rules.

All facts with a typed schema (local and cross-spec) are included. Spec-reference facts (which have no schema type) are excluded. Only local rules (no cross-spec segments) are included. Facts and rules are sorted by source position (definition order).

pub fn schema_for_rules( &self, rule_names: &[String], ) -> Result<SpecSchema, Error>

Build a SpecSchema scoped to specific rules.

The returned schema contains only the facts needed by the given rules (transitively, via needs_facts) and only those rules. This is the “what do I need to evaluate these rules?” view. Facts are sorted by source position (definition order).

Returns Err if any rule name is not found in the plan.

pub fn get_fact_path_by_str(&self, name: &str) -> Option<&FactPath>

Look up a fact by its input key (e.g., “age” or “rules.base_price”).

pub fn get_rule(&self, name: &str) -> Option<&ExecutableRule>

Look up a local rule by its name (rule in the main spec).

pub fn get_rule_by_path(&self, rule_path: &RulePath) -> Option<&ExecutableRule>

Look up a rule by its full path.

pub fn get_fact_value(&self, path: &FactPath) -> Option<&LiteralValue>

Get the literal value for a fact path, if it exists and has a literal value.

pub fn with_fact_values( self, values: HashMap<String, String>, limits: &ResourceLimits, ) -> Result<Self, Error>

Provide string values for facts.

Parses each string to its expected type, validates constraints, and applies to the plan.

Trait Implementations

impl Clone for ExecutionPlan

fn clone(&self) -> ExecutionPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecutionPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ExecutionPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.