Struct ExecutionPlan 

pub struct ExecutionPlan {
    pub spec_name: String,
    pub data: IndexMap<DataPath, DataDefinition>,
    pub rules: Vec<ExecutableRule>,
    pub reference_evaluation_order: Vec<DataPath>,
    pub meta: HashMap<String, MetaValue>,
    pub named_types: BTreeMap<String, LemmaType>,
    pub effective: EffectiveDate,
    pub sources: SpecSources,
}

A complete execution plan ready for the evaluator

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

Fields

spec_name: String

Main spec name

data: IndexMap<DataPath, DataDefinition>

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

rules: Vec<ExecutableRule>

Rules to execute in topological order (sorted by dependencies)

reference_evaluation_order: Vec<DataPath>

Order in which DataDefinition::Reference entries must be resolved at evaluation time so that chained references (reference → reference → data) copy values in the correct sequence. Empty when the plan has no references.

meta: HashMap<String, MetaValue>

Spec metadata

named_types: BTreeMap<String, LemmaType>

Named types defined in or imported by this spec, in deterministic order.

effective: EffectiveDate

sources: SpecSources

Canonical source for all specs in this plan, keyed by (name, effective_from). Reconstructed from AST — not raw file content.

Implementations

impl ExecutionPlan

pub fn schema(&self) -> SpecSchema

Build a SpecSchema describing this plan’s public IO contract.

Only data transitively reachable from at least one local rule (via needs_data) are included. Spec-reference data (which have no schema type) are also excluded. Only local rules (no cross-spec segments) are included. Data 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 data needed by the given rules (transitively, via needs_data) and only those rules. This is the “what do I need to evaluate these rules?” view. Data are sorted by source position (definition order).

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

pub fn get_data_path_by_str(&self, name: &str) -> Option<&DataPath>

Look up a data 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_data_value(&self, path: &DataPath) -> Option<&LiteralValue>

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

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

Provide string values for data.

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.