Enum ObservationExpression 

pub enum ObservationExpression {
    Observation {
        expression: Box<ComparisonExpression>,
        span: Span,
    },
    And(Vec<ObservationExpression>),
    Or(Vec<ObservationExpression>),
    FollowedBy(Vec<ObservationExpression>),
    Qualified {
        expression: Box<ObservationExpression>,
        qualifier: Qualifier,
        span: Span,
    },
}

Observation-level expression tree. FOLLOWEDBY/AND/OR combine observations; qualifiers attach to a sub-expression.

Chain nodes

And, Or and FollowedBy are n-ary: a chain such as a OR b OR c is a single node holding every operand in source order, so the tree’s depth does not grow with the length of a chain. Nodes produced by parse uphold two invariants:

• the operand list has at least two elements;
• the first operand is never a node of the same operator. Left-nested chains are flattened ((a OR b) OR c and a OR b OR c are both Or([a, b, c])), while a right-nested group keeps its own node (a OR (b OR c) is Or([a, Or([b, c])])).

A chain Op([a, b, c]) means the left-associative (a op b) op c.

In JSON a two-operand chain serializes as {"Or": [l, r]}, and longer chains as longer arrays.

Variants

Observation

A single [ comparisonExpr ] observation.

Fields

expression: Box<ComparisonExpression>

The comparison expression inside the brackets.

span: Span

Byte range of the whole [...] including the brackets.

And(Vec<ObservationExpression>)

AND of two or more observation expressions (see chain nodes).

Or(Vec<ObservationExpression>)

OR of two or more observation expressions (see chain nodes).

FollowedBy(Vec<ObservationExpression>)

FOLLOWEDBY of two or more observation expressions: each operand’s observations precede the next’s (see chain nodes).

Qualified

A sub-expression with a postfix Qualifier attached.

Fields

expression: Box<ObservationExpression>

The qualified sub-expression.

qualifier: Qualifier

The attached qualifier.

span: Span

Byte range of the qualifier clause only (e.g. WITHIN 60 SECONDS).

Trait Implementations

impl Clone for ObservationExpression

fn clone(&self) -> ObservationExpression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ObservationExpression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ObservationExpression

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ObservationExpression

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ObservationExpression

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 ObservationExpression