Enum ComputedExpr 

pub enum ComputedExpr {
    FieldRef {
        path: String,
    },
    UnwrapOr {
        expr: Box<ComputedExpr>,
        default: Value,
    },
    Binary {
        op: BinaryOp,
        left: Box<ComputedExpr>,
        right: Box<ComputedExpr>,
    },
    Cast {
        expr: Box<ComputedExpr>,
        to_type: String,
    },
    MethodCall {
        expr: Box<ComputedExpr>,
        method: String,
        args: Vec<ComputedExpr>,
    },
    Literal {
        value: Value,
    },
    Paren {
        expr: Box<ComputedExpr>,
    },
    Var {
        name: String,
    },
    Let {
        name: String,
        value: Box<ComputedExpr>,
        body: Box<ComputedExpr>,
    },
    If {
        condition: Box<ComputedExpr>,
        then_branch: Box<ComputedExpr>,
        else_branch: Box<ComputedExpr>,
    },
    None,
    Some {
        value: Box<ComputedExpr>,
    },
    Slice {
        expr: Box<ComputedExpr>,
        start: usize,
        end: usize,
    },
    Index {
        expr: Box<ComputedExpr>,
        index: usize,
    },
    U64FromLeBytes {
        bytes: Box<ComputedExpr>,
    },
    U64FromBeBytes {
        bytes: Box<ComputedExpr>,
    },
    ByteArray {
        bytes: Vec<u8>,
    },
    Closure {
        param: String,
        body: Box<ComputedExpr>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<ComputedExpr>,
    },
    JsonToBytes {
        expr: Box<ComputedExpr>,
    },
}

AST for computed field expressions Supports a subset of Rust expressions needed for computed fields:

• Field references (possibly from other sections)
• Unwrap with defaults
• Basic arithmetic and comparisons
• Type casts
• Method calls
• Let bindings and conditionals
• Byte array operations

Variants

FieldRef

Reference to a field: “field_name” or “section.field_name”

Fields

path: String

UnwrapOr

Unwrap with default: expr.unwrap_or(default)

Fields

expr: Box<ComputedExpr>

default: Value

Binary

Binary operation: left op right

Fields

op: BinaryOp

left: Box<ComputedExpr>

right: Box<ComputedExpr>

Cast

Type cast: expr as type

Fields

expr: Box<ComputedExpr>

to_type: String

MethodCall

Method call: expr.method(args)

Fields

expr: Box<ComputedExpr>

method: String

args: Vec<ComputedExpr>

Literal

Literal value: numbers, booleans, strings

Fields

value: Value

Paren

Parenthesized expression for grouping

Fields

expr: Box<ComputedExpr>

Var

Fields

name: String

Let

Fields

name: String

value: Box<ComputedExpr>

body: Box<ComputedExpr>

If

Fields

condition: Box<ComputedExpr>

then_branch: Box<ComputedExpr>

else_branch: Box<ComputedExpr>

None

Some

Fields

value: Box<ComputedExpr>

Slice

Fields

expr: Box<ComputedExpr>

start: usize

end: usize

Index

Fields

expr: Box<ComputedExpr>

index: usize

U64FromLeBytes

Fields

bytes: Box<ComputedExpr>

U64FromBeBytes

Fields

bytes: Box<ComputedExpr>

ByteArray

Fields

bytes: Vec<u8>

Closure

Fields

param: String

body: Box<ComputedExpr>

Unary

Fields

op: UnaryOp

expr: Box<ComputedExpr>

JsonToBytes

Fields

expr: Box<ComputedExpr>

Trait Implementations

impl Clone for ComputedExpr

fn clone(&self) -> ComputedExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComputedExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ComputedExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ComputedExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.