Enum Reference

pub enum Reference {
    One(String),
    Two(String, String),
    Three(String, String, String),
}

Represents a variable reference in an AIMX expression.

The Reference enum defines the structure of variable references used throughout the AIMX language. References can be simple identifiers or chained property accessors. They are used to access values from the evaluation context.

Variants

• One(String) - A single identifier reference (e.g., variable)
• Two(String, String) - A two-part chained reference (e.g., object.property)
• Three(String, String, String) - A three-part chained reference (e.g., object.property.method)

Examples

use aimx::expressions::reference::Reference;

// Create references programmatically
let simple = Reference::One("variable".to_string());
let chained = Reference::Two("object".to_string(), "property".to_string());
let nested = Reference::Three("parent".to_string(), "child".to_string(), "method".to_string());

// References implement Display for easy formatting
assert_eq!(simple.to_string(), "variable");
assert_eq!(chained.to_string(), "object.property");
assert_eq!(nested.to_string(), "parent.child.method");

Variants

One(String)

A single identifier reference

Two(String, String)

A two-part chained property reference

Three(String, String, String)

A three-part chained property reference

Implementations

impl Reference

pub fn new(identifier: &str) -> Self

pub fn append(&self, identifier: &str) -> Result<Reference>

pub fn normalize(&self, reference: &Reference) -> Result<Reference>

pub fn to_path(&self, workspace: &Path) -> PathBuf

pub fn create_path(&self, workspace: &Path) -> Result<PathBuf>

Trait Implementations

impl Clone for Reference

fn clone(&self) -> Reference

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Reference

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

Formats the value using the given formatter.

impl Display for Reference

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

Formats the value using the given formatter.

impl ExpressionLike for Reference

fn evaluate(&self, context: &mut dyn ContextLike) -> Result<Value>

Evaluate this reference by looking up its value in the context.

Arguments

• context - The evaluation context to lookup the reference in

Returns

Returns a Result<Value> containing the value of the referenced variable or an error if the reference cannot be resolved.

fn write(&self, writer: &mut Writer)

Write this expression to the provided writer.

fn to_sanitized(&self) -> String

Convert this expression to a sanitized string representation.

fn to_formula(&self) -> String

Convert this expression to a formula string representation.

impl Hash for Reference

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Reference> for String

fn eq(&self, other: &Reference) -> 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 PartialEq<Reference> for Workflow

fn eq(&self, other: &Reference) -> 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 PartialEq<String> for Reference

fn eq(&self, other: &String) -> 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 PartialEq<Workflow> for Reference

fn eq(&self, other: &Workflow) -> 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 PartialEq for Reference

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

impl StructuralPartialEq for Reference