Enum Expression

pub enum Expression {
    Field(FieldNode),
    LastField(LastFieldNode),
    And(AndNode),
    Or(OrNode),
    Not(NotNode),
    Op(OpNode),
    Literal(LiteralNode),
    Function(FunctionNode),
    Iif(IifNode),
    List(ListNode),
}

An expression that can be inspected or evaluated

Variants

Field(FieldNode)

A node representing a reference to a field

E.g. MlsStatus

LastField(LastFieldNode)

A node representing a reference to a field from the previous value

E.g. LAST MlsStatus

And(AndNode)

A node representing the logical conjunction of two or more expressions

E.g. A .AND. B

Or(OrNode)

A node representing the logical disjunction of two or more expressions

E.g. A .OR. B

Not(NotNode)

A node representing the logical negation of an expression

E.g. .NOT. A

Op(OpNode)

A node representing a binary operation

E.g. A + B

Literal(LiteralNode)

A node representing a literal value

E.g. .TRUE.

Function(FunctionNode)

A node representing a function call

E.g. SUBSTR('A', 1, 2)

Iif(IifNode)

A node representing the special IIF conditional syntax

E.g. IIF(A, B, C)

List(ListNode)

A node representing a list of items

E.g. (1, 2, 3)

Implementations

impl Expression

pub fn serialize(&self) -> Result<String, Error>

Serialize the expression to a string

pub fn format<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write,

Serialize the expression to a writer

impl Expression

pub fn accept(&mut self, visitor: &mut impl Visitor)

Visit this node with the provided visitor

impl Expression

pub fn as_field(&self) -> Option<&FieldNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_field_mut(&mut self) -> Option<&mut FieldNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_last_field(&self) -> Option<&LastFieldNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_last_field_mut(&mut self) -> Option<&mut LastFieldNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_and(&self) -> Option<&AndNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_and_mut(&mut self) -> Option<&mut AndNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_or(&self) -> Option<&OrNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_or_mut(&mut self) -> Option<&mut OrNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_not(&self) -> Option<&NotNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_not_mut(&mut self) -> Option<&mut NotNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_op(&self) -> Option<&OpNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_op_mut(&mut self) -> Option<&mut OpNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_literal(&self) -> Option<&LiteralNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_literal_mut(&mut self) -> Option<&mut LiteralNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_function(&self) -> Option<&FunctionNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_function_mut(&mut self) -> Option<&mut FunctionNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_iif(&self) -> Option<&IifNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_iif_mut(&mut self) -> Option<&mut IifNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

pub fn as_list(&self) -> Option<&ListNode>

If the Expression is a X, returns a reference to the associated Y. Returns None otherwise.

pub fn as_list_mut(&mut self) -> Option<&mut ListNode>

If the Expression is a X, returns a mutable reference to the associated Y. Returns None otherwise.

impl Expression

pub fn apply<'expr, 'val, T>( &'expr self, context: EvaluateContext<'_, 'val, T>, ) -> Result<Cow<'val, Value>, Error>

where 'expr: 'val,

Run the expression to completion and return the result

pub fn apply_with_locals<'expr, 'val, T>( &'expr self, context: EvaluateContext<'_, 'val, T>, locals: &BTreeMap<&'expr str, Cow<'val, Value>>, ) -> Result<Cow<'val, Value>, Error>

where 'expr: 'val,

Run the expression to completion and return the result

Locals can be used to augment or override the provided JSON values.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy 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 From<AndNode> for Expression

fn from(node: AndNode) -> Expression

Converts to this type from the input type.

impl From<FieldNode> for Expression

fn from(node: FieldNode) -> Expression

Converts to this type from the input type.

impl From<FunctionNode> for Expression

fn from(node: FunctionNode) -> Expression

Converts to this type from the input type.

impl From<IifNode> for Expression

fn from(node: IifNode) -> Expression

Converts to this type from the input type.

impl From<LastFieldNode> for Expression

fn from(node: LastFieldNode) -> Expression

Converts to this type from the input type.

impl From<ListNode> for Expression

fn from(node: ListNode) -> Expression

Converts to this type from the input type.

impl From<LiteralNode> for Expression

fn from(node: LiteralNode) -> Expression

Converts to this type from the input type.

impl From<NotNode> for Expression

fn from(node: NotNode) -> Expression

Converts to this type from the input type.

impl From<OpNode> for Expression

fn from(node: OpNode) -> Expression

Converts to this type from the input type.

impl From<OrNode> for Expression

fn from(node: OrNode) -> Expression

Converts to this type from the input type.

impl FromStr for Expression

type Err = String

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 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 Eq for Expression

impl StructuralPartialEq for Expression