Enum Expression 

pub enum Expression {
    StringLiteral(SmolStr),
    NumberLiteral(f64),
    BoolLiteral(bool),
    PropertyReference(PropertyReference),
    FunctionParameterReference {
        index: usize,
    },
    StoreLocalVariable {
        name: SmolStr,
        value: Box<Expression>,
    },
    ReadLocalVariable {
        name: SmolStr,
        ty: Type,
    },
    StructFieldAccess {
        base: Box<Expression>,
        name: SmolStr,
    },
    ArrayIndex {
        array: Box<Expression>,
        index: Box<Expression>,
    },
    Cast {
        from: Box<Expression>,
        to: Type,
    },
    CodeBlock(Vec<Expression>),
    BuiltinFunctionCall {
        function: BuiltinFunction,
        arguments: Vec<Expression>,
    },
    CallBackCall {
        callback: PropertyReference,
        arguments: Vec<Expression>,
    },
    FunctionCall {
        function: PropertyReference,
        arguments: Vec<Expression>,
    },
    ItemMemberFunctionCall {
        function: PropertyReference,
    },
    ExtraBuiltinFunctionCall {
        return_ty: Type,
        function: String,
        arguments: Vec<Expression>,
    },
    PropertyAssignment {
        property: PropertyReference,
        value: Box<Expression>,
    },
    ModelDataAssignment {
        level: usize,
        value: Box<Expression>,
    },
    ArrayIndexAssignment {
        array: Box<Expression>,
        index: Box<Expression>,
        value: Box<Expression>,
    },
    BinaryExpression {
        lhs: Box<Expression>,
        rhs: Box<Expression>,
        op: char,
    },
    UnaryOp {
        sub: Box<Expression>,
        op: char,
    },
    ImageReference {
        resource_ref: ImageReference,
        nine_slice: Option<[u16; 4]>,
    },
    Condition {
        condition: Box<Expression>,
        true_expr: Box<Expression>,
        false_expr: Box<Expression>,
    },
    Array {
        element_ty: Type,
        values: Vec<Expression>,
        as_model: bool,
    },
    Struct {
        ty: Rc<Struct>,
        values: BTreeMap<SmolStr, Expression>,
    },
    EasingCurve(EasingCurve),
    LinearGradient {
        angle: Box<Expression>,
        stops: Vec<(Expression, Expression)>,
    },
    RadialGradient {
        stops: Vec<(Expression, Expression)>,
    },
    ConicGradient {
        stops: Vec<(Expression, Expression)>,
    },
    EnumerationValue(EnumerationValue),
    LayoutCacheAccess {
        layout_cache_prop: PropertyReference,
        index: usize,
        repeater_index: Option<Box<Expression>>,
    },
    BoxLayoutFunction {
        cells_variable: String,
        repeater_indices: Option<SmolStr>,
        elements: Vec<Either<Expression, RepeatedElementIdx>>,
        orientation: Orientation,
        sub_expression: Box<Expression>,
    },
    ComputeDialogLayoutCells {
        cells_variable: String,
        roles: Box<Expression>,
        unsorted_cells: Box<Expression>,
    },
    MinMax {
        ty: Type,
        op: MinMaxOp,
        lhs: Box<Expression>,
        rhs: Box<Expression>,
    },
    EmptyComponentFactory,
    TranslationReference {
        format_args: Box<Expression>,
        string_index: usize,
        plural: Option<Box<Expression>>,
    },
}

Variants

StringLiteral(SmolStr)

A string literal. The .0 is the content of the string, without the quotes

NumberLiteral(f64)

Number

BoolLiteral(bool)

Bool

PropertyReference(PropertyReference)

Reference to a property (which can also be a callback) or an element (property name is empty then).

FunctionParameterReference

Reference the parameter at the given index of the current function.

Fields

index: usize

StoreLocalVariable

Should be directly within a CodeBlock expression, and store the value of the expression in a local variable

Fields

name: SmolStr

value: Box<Expression>

ReadLocalVariable

a reference to the local variable with the given name. The type system should ensure that a variable has been stored with this name and this type before in one of the statement of an enclosing codeblock

Fields

name: SmolStr

ty: Type

StructFieldAccess

Access to a field of the given name within a struct.

Fields

base: Box<Expression>

This expression should have Type::Struct type

name: SmolStr

ArrayIndex

Access to a index within an array.

Fields

array: Box<Expression>

This expression should have Type::Array type

index: Box<Expression>

Cast

Cast an expression to the given type

Fields

from: Box<Expression>

to: Type

CodeBlock(Vec<Expression>)

a code block with different expression

BuiltinFunctionCall

A function call

Fields

function: BuiltinFunction

arguments: Vec<Expression>

CallBackCall

Fields

callback: PropertyReference

arguments: Vec<Expression>

FunctionCall

Fields

function: PropertyReference

arguments: Vec<Expression>

ItemMemberFunctionCall

Fields

function: PropertyReference

ExtraBuiltinFunctionCall

A BuiltinFunctionCall, but the function is not yet in the BuiltinFunction enum TODO: merge in BuiltinFunctionCall

Fields

return_ty: Type

function: String

arguments: Vec<Expression>

PropertyAssignment

An assignment of a value to a property

Fields

property: PropertyReference

value: Box<Expression>

ModelDataAssignment

an assignment of a value to the model data

Fields

level: usize

value: Box<Expression>

ArrayIndexAssignment

An assignment done with the foo[idx] = ...

Fields

array: Box<Expression>

index: Box<Expression>

value: Box<Expression>

BinaryExpression

Fields

lhs: Box<Expression>

rhs: Box<Expression>

op: char

‘+’, ‘-’, ‘/’, ‘*’, ‘=’, ‘!’, ‘<’, ‘>’, ‘≤’, ‘≥’, ‘&’, ‘|’

UnaryOp

Fields

sub: Box<Expression>

op: char

‘+’, ‘-’, ‘!’

ImageReference

Fields

resource_ref: ImageReference

nine_slice: Option<[u16; 4]>

Condition

Fields

condition: Box<Expression>

true_expr: Box<Expression>

false_expr: Box<Expression>

Array

Fields

element_ty: Type

values: Vec<Expression>

as_model: bool

When true, this should be converted to a model. When false, this should stay as a slice

Struct

Fields

ty: Rc<Struct>

values: BTreeMap<SmolStr, Expression>

EasingCurve(EasingCurve)

LinearGradient

Fields

angle: Box<Expression>

stops: Vec<(Expression, Expression)>

First expression in the tuple is a color, second expression is the stop position

RadialGradient

Fields

stops: Vec<(Expression, Expression)>

First expression in the tuple is a color, second expression is the stop position

ConicGradient

Fields

stops: Vec<(Expression, Expression)>

First expression in the tuple is a color, second expression is the stop position (normalized angle 0-1)

EnumerationValue(EnumerationValue)

LayoutCacheAccess

Fields

layout_cache_prop: PropertyReference

index: usize

repeater_index: Option<Box<Expression>>

When set, this is the index within a repeater, and the index is then the location of another offset. So this looks like layout_cache_prop[layout_cache_prop[index] + repeater_index]

BoxLayoutFunction

Will call the sub_expression, with the cell variable set to the array of BoxLayoutCellData from the elements

Fields

cells_variable: String

The local variable (as read with Self::ReadLocalVariable) that contains the sell

repeater_indices: Option<SmolStr>

The name for the local variable that contains the repeater indices

elements: Vec<Either<Expression, RepeatedElementIdx>>

Either an expression of type BoxLayoutCellData, or an index to the repeater

orientation: Orientation

sub_expression: Box<Expression>

ComputeDialogLayoutCells

Fields

cells_variable: String

The local variable where the slice of cells is going to be stored

roles: Box<Expression>

unsorted_cells: Box<Expression>

This is an Expression::Array

MinMax

Fields

ty: Type

op: MinMaxOp

lhs: Box<Expression>

rhs: Box<Expression>

EmptyComponentFactory

TranslationReference

A reference to bundled translated string

Fields

format_args: Box<Expression>

An expression of type array of strings

string_index: usize

plural: Option<Box<Expression>>

The n value to use for the plural form if it is a plural form

Implementations

impl Expression

pub fn default_value_for_type(ty: &Type) -> Option<Self>

pub fn ty(&self, ctx: &dyn TypeResolutionContext) -> Type

impl Expression

pub fn visit(&self, visitor: impl FnMut(&Self))

Call the visitor for each sub-expression (not recursive)

pub fn visit_mut(&mut self, visitor: impl FnMut(&mut Self))

Call the visitor for each sub-expression (not recursive)

pub fn visit_recursive(&self, visitor: &mut dyn FnMut(&Self))

Visit itself and each sub expression recursively

pub fn visit_property_references( &self, ctx: &EvaluationContext<'_>, visitor: &mut dyn FnMut(&PropertyReference, &EvaluationContext<'_>), )

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 From<Expression> for MutExpression

fn from(e: Expression) -> Self

Converts to this type from the input type.