Enum Op 

pub enum Op {
    Load {
        path: ObjectPath,
    },
    Compare {
        operator: ComparisonOperator,
        negated: bool,
        lhs: InstrId,
        rhs: Operand,
    },
    And {
        lhs: InstrId,
        rhs: InstrId,
    },
    Or {
        lhs: InstrId,
        rhs: InstrId,
    },
    Yield {
        value: InstrId,
    },
    Observe {
        block: BlockId,
    },
    FollowedBy {
        lhs: InstrId,
        rhs: InstrId,
    },
    Within {
        input: InstrId,
        seconds: f64,
    },
    Repeats {
        input: InstrId,
        count: u64,
    },
    StartStop {
        input: InstrId,
        start: String,
        stop: String,
    },
    Ret {
        value: InstrId,
    },
}

One three-address operation.

Instructions in a BlockKind::Comparison block use the comparison-tier ops (Load, Compare, And, Or, Yield); instructions in the BlockKind::Main block use the observation-tier ops. And and Or are shared between the tiers and take their evaluation semantics from the enclosing block’s kind.

Variants

Load

Resolve an object path to a value.

Fields

path: ObjectPath

The path to resolve.

Compare

Apply a comparison operator to a loaded value and an operand.

Fields

operator: ComparisonOperator

The comparison operator.

negated: bool

true if a NOT preceded the operator in the source.

lhs: InstrId

The loaded value being compared.

rhs: Operand

The right-hand side.

And

Boolean conjunction of two values.

Fields

lhs: InstrId

Left operand.

rhs: InstrId

Right operand.

Or

Boolean disjunction of two values.

Fields

lhs: InstrId

Left operand.

rhs: InstrId

Right operand.

Yield

Terminator of a comparison block: its result.

Fields

value: InstrId

The value the block evaluates to.

Observe

Evaluate a comparison block against an observation.

Fields

block: BlockId

The comparison block to evaluate.

FollowedBy

FOLLOWEDBY: the left result’s observations precede the right’s.

Fields

lhs: InstrId

Left operand.

rhs: InstrId

Right operand.

Within

WITHIN <seconds> SECONDS applied to a result.

Fields

input: InstrId

The result being qualified.

seconds: f64

The window length in seconds.

Repeats

REPEATS <count> TIMES applied to a result.

Fields

input: InstrId

The result being qualified.

count: u64

The required repetition count.

StartStop

START <start> STOP <stop> applied to a result.

Fields

input: InstrId

The result being qualified.

start: String

Inclusive window start, RFC3339.

stop: String

Exclusive window stop, RFC3339.

Ret

Terminator of the main block: the program’s result.

Fields

value: InstrId

The value the program evaluates to.

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Op

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Op

fn eq(&self, other: &Op) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Op

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 Op