Enum Expression 

pub enum Expression {
    IntLiteral {
        value: i64,
    },
    BoolLiteral {
        value: bool,
    },
    Null,
    Param {
        index: u32,
    },
    FieldAccess {
        object: Box<Expression>,
        class_name: String,
        field_name: String,
    },
    Eq {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Ne {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Lt {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Le {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Gt {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Ge {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    And {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Or {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Not {
        operand: Box<Expression>,
    },
    IsNull {
        operand: Box<Expression>,
    },
    IsNotNull {
        operand: Box<Expression>,
    },
    Add {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Sub {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Mul {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Div {
        left: Box<Expression>,
        right: Box<Expression>,
    },
    ListContains {
        list: Box<Expression>,
        element: Box<Expression>,
    },
    HostCall {
        function_name: String,
        args: Vec<Expression>,
    },
    IfThenElse {
        condition: Box<Expression>,
        then_branch: Box<Expression>,
        else_branch: Box<Expression>,
    },
}

Rich expression tree for constraint predicates

This enum represents a complete expression language for building constraint predicates. Expressions are serializable (via serde) for use across FFI boundaries.

Example

// Build expression: param(0).employee != null
let expr = Expression::IsNotNull {
    operand: Box::new(Expression::FieldAccess {
        object: Box::new(Expression::Param { index: 0 }),
        class_name: "Shift".into(),
        field_name: "employee".into(),
    })
};

Variants

IntLiteral

Integer literal (i64)

Fields

value: i64

BoolLiteral

Boolean literal

Fields

value: bool

Null

Null value

Param

Access a function parameter by index Example: param(0) refers to the first parameter

Fields

index: u32

FieldAccess

Access a field on an object Example: param(0).get(“Employee”, “name”)

Fields

object: Box<Expression>

class_name: String

field_name: String

Eq

Equal comparison (==)

Fields

left: Box<Expression>

right: Box<Expression>

Ne

Not equal comparison (!=)

Fields

left: Box<Expression>

right: Box<Expression>

Lt

Less than comparison (<)

Fields

left: Box<Expression>

right: Box<Expression>

Le

Less than or equal comparison (<=)

Fields

left: Box<Expression>

right: Box<Expression>

Gt

Greater than comparison (>)

Fields

left: Box<Expression>

right: Box<Expression>

Ge

Greater than or equal comparison (>=)

Fields

left: Box<Expression>

right: Box<Expression>

And

Logical AND (&&)

Fields

left: Box<Expression>

right: Box<Expression>

Or

Logical OR (||)

Fields

left: Box<Expression>

right: Box<Expression>

Not

Logical NOT (!)

Fields

operand: Box<Expression>

IsNull

Null check (is null)

Fields

operand: Box<Expression>

IsNotNull

Not-null check (is not null)

Fields

operand: Box<Expression>

Add

Addition (+)

Fields

left: Box<Expression>

right: Box<Expression>

Sub

Subtraction (-)

Fields

left: Box<Expression>

right: Box<Expression>

Mul

Multiplication (*)

Fields

left: Box<Expression>

right: Box<Expression>

Div

Division (/)

Fields

left: Box<Expression>

right: Box<Expression>

ListContains

Check if a list contains an element Example: list.contains(element)

Fields

list: Box<Expression>

element: Box<Expression>

HostCall

Call a host-provided function Example: hstringEquals(left, right)

Fields

function_name: String

args: Vec<Expression>

IfThenElse

If-then-else conditional expression Example: if condition { then_branch } else { else_branch }

Fields

condition: Box<Expression>

then_branch: Box<Expression>

else_branch: Box<Expression>

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<'de> Deserialize<'de> for Expression

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FieldAccessExt for Expression

fn get(self, class_name: &str, field_name: &str) -> Expression

Access a field on this 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 Serialize for Expression

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expression