Enum OpCode 

#[repr(u8)]
pub enum OpCode {
    Var = 0,
    Val = 1,
    Exists = 57,
    Equals = 2,
    StrictEquals = 3,
    NotEquals = 4,
    StrictNotEquals = 5,
    GreaterThan = 6,
    GreaterThanEqual = 7,
    LessThan = 8,
    LessThanEqual = 9,
    Not = 10,
    DoubleNot = 11,
    And = 12,
    Or = 13,
    If = 14,
    Ternary = 15,
    Coalesce = 56,
    Add = 16,
    Subtract = 17,
    Multiply = 18,
    Divide = 19,
    Modulo = 20,
    Max = 21,
    Min = 22,
    Abs = 49,
    Ceil = 50,
    Floor = 51,
    Cat = 23,
    Substr = 24,
    In = 25,
    Length = 53,
    StartsWith = 38,
    EndsWith = 39,
    Upper = 40,
    Lower = 41,
    Trim = 42,
    Split = 43,
    Merge = 26,
    Filter = 27,
    Map = 28,
    Reduce = 29,
    All = 30,
    Some = 31,
    None = 32,
    Sort = 54,
    Slice = 55,
    Datetime = 44,
    Timestamp = 45,
    ParseDate = 46,
    FormatDate = 47,
    DateDiff = 48,
    Now = 58,
    Try = 35,
    Throw = 36,
    Type = 37,
    Missing = 33,
    MissingSome = 34,
    Preserve = 52,
}

OpCode enum for fast built-in operator lookup

Variants

Var = 0

Val = 1

Exists = 57

Equals = 2

StrictEquals = 3

NotEquals = 4

StrictNotEquals = 5

GreaterThan = 6

GreaterThanEqual = 7

LessThan = 8

LessThanEqual = 9

Not = 10

DoubleNot = 11

And = 12

Or = 13

If = 14

Ternary = 15

Coalesce = 56

Add = 16

Subtract = 17

Multiply = 18

Divide = 19

Modulo = 20

Max = 21

Min = 22

Abs = 49

Ceil = 50

Floor = 51

Cat = 23

Substr = 24

In = 25

Length = 53

StartsWith = 38

EndsWith = 39

Upper = 40

Lower = 41

Trim = 42

Split = 43

Merge = 26

Filter = 27

Map = 28

Reduce = 29

All = 30

Some = 31

None = 32

Sort = 54

Slice = 55

Datetime = 44

Timestamp = 45

ParseDate = 46

FormatDate = 47

DateDiff = 48

Now = 58

Try = 35

Throw = 36

Type = 37

Missing = 33

MissingSome = 34

Preserve = 52

Implementations

impl OpCode

pub const COUNT: usize = 59

Total number of built-in operators

pub fn as_str(&self) -> &'static str

Convert OpCode back to string (for debugging/display)

pub fn evaluate_direct( &self, args: &[CompiledNode], context: &mut ContextStack, engine: &DataLogic, ) -> Result<Value>

Direct evaluation method - no boxing, no vtables, no array lookups

pub fn evaluate_traced( &self, args: &[CompiledNode], context: &mut ContextStack, engine: &DataLogic, collector: &mut TraceCollector, node_id_map: &HashMap<usize, u32>, ) -> Result<Value>

Traced evaluation method - records steps for debugging.

This method dispatches to traced versions of operators that need special handling (iteration and short-circuit operators), while regular operators use the standard evaluation with child tracing.

Trait Implementations

impl Clone for OpCode

fn clone(&self) -> OpCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpCode

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

Formats the value using the given formatter.

impl FromStr for OpCode

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for OpCode

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

impl Eq for OpCode

impl StructuralPartialEq for OpCode