Enum Expression 

pub enum Expression {
    LiteralInteger(i64),
    LiteralReal(String),
    LiteralString(String),
    LiteralBoolean(bool),
    FeatureRef(String),
    MemberAccess(Box<Node<Expression>>, String),
    Index {
        base: Box<Node<Expression>>,
        index: Box<Node<Expression>>,
    },
    Bracket(Box<Node<Expression>>),
    LiteralWithUnit {
        value: Box<Node<Expression>>,
        unit: Box<Node<Expression>>,
    },
    BinaryOp {
        op: BinaryOperator,
        left: Box<Node<Expression>>,
        right: Box<Node<Expression>>,
    },
    UnaryOp {
        op: UnaryOperator,
        operand: Box<Node<Expression>>,
    },
    Invocation {
        callee: Box<Node<Expression>>,
        args: Vec<Node<Expression>>,
    },
    Tuple(Vec<Node<Expression>>),
    Classification {
        metaclass: String,
    },
    TypeCheck {
        kind: TypeCheckKind,
        operand: Option<Box<Node<Expression>>>,
        type_name: String,
    },
    Select {
        base: Box<Node<Expression>>,
        selector: String,
    },
    Collect {
        base: Box<Node<Expression>>,
        selector: String,
    },
    Null,
}

Expression: literals, feature refs, member access, index, bracket/unit, etc.

Variants

LiteralInteger(i64)

LiteralReal(String)

LiteralString(String)

LiteralBoolean(bool)

FeatureRef(String)

Single name or qualified name.

MemberAccess(Box<Node<Expression>>, String)

base.member (e.g. engine.fuelCmdPort).

Index

base#(index) e.g. frontWheel#(1).

Fields

base: Box<Node<Expression>>

index: Box<Node<Expression>>

Bracket(Box<Node<Expression>>)

unit e.g. [kg].

LiteralWithUnit

value unit e.g. 1750 [kg].

Fields

value: Box<Node<Expression>>

unit: Box<Node<Expression>>

BinaryOp

Binary infix operation e.g. a >= b * c, x / y.

Fields

op: BinaryOperator

left: Box<Node<Expression>>

right: Box<Node<Expression>>

UnaryOp

Unary prefix: + - ~ not

Fields

op: UnaryOperator

operand: Box<Node<Expression>>

Invocation

Function-like invocation, e.g. ComputeMargin(a, b).

Fields

callee: Box<Node<Expression>>

args: Vec<Node<Expression>>

Tuple(Vec<Node<Expression>>)

Comma-separated sequence in parentheses, e.g. (engine1, engine2) for ordered composition values.

Classification

Metadata classification: @Metaclass (e.g. @SysML::PartUsage).

Fields

metaclass: String

TypeCheck

Type test: expr istype Type, expr hastype Type, or expr as Type.

Fields

kind: TypeCheckKind

operand: Option<Box<Node<Expression>>>

type_name: String

Select

Select expression: base.?selector.

Fields

base: Box<Node<Expression>>

selector: String

Collect

Collect expression: base.**selector.

Fields

base: Box<Node<Expression>>

selector: String

Null

KerML null or empty sequence ().

Implementations

impl Expression

pub fn is_boolean_literal(&self) -> bool

Whether this expression node is a literal Boolean.

pub fn is_classification(&self) -> bool

Whether this expression is a metadata @Metaclass classification.

pub fn is_type_check(&self) -> bool

Whether this expression is a KerML type test (istype / hastype / as).

pub fn binary_op_is_comparison(op: &BinaryOperator) -> bool

Whether a binary operator is a comparison.

pub fn binary_op_is_logical(op: &BinaryOperator) -> bool

Whether a binary operator is logical (and / or / xor / implies).

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Eq for Expression

impl PartialEq for Expression

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