Enum Expr 

pub enum Expr {
    Or(Box<Expr>, Box<Expr>),
    And(Box<Expr>, Box<Expr>),
    Not(Box<Expr>),
    Compare(Box<Expr>, CompareOperator, Box<Expr>),
    In(Box<Expr>, Vec<Expr>),
    Function(String, Vec<Expr>),
    Identifier(String),
    Value(Value),
}

Represents the different types of expressions in the AST.

Variants

Or(Box<Expr>, Box<Expr>)

Logical OR between two expressions.

And(Box<Expr>, Box<Expr>)

Logical AND between two expressions.

Not(Box<Expr>)

Logical NOT to invert an expression.

Compare(Box<Expr>, CompareOperator, Box<Expr>)

Comparison between two expressions.

In(Box<Expr>, Vec<Expr>)

In operator to check if a value is within a list of values.

Function(String, Vec<Expr>)

Function call with a name and a list of arguments.

Identifier(String)

An identifier.

Value(Value)

A constant value.

Implementations

impl Expr

pub fn are_types_valid( &self, identifiers: &IdentifiersTypeMap, functions: &FunctionsTypeMap, ) -> Result<bool, ValidationError>

Validates if the types within the expression are correct and if the expression overall is a boolean type.

A Result which is Ok(true) if the expression is a valid boolean expression, or an Err with a ValidationError if the types are not valid.

use std::collections::HashMap;
use odata_params::filters::{Expr, FunctionsTypeMap, IdentifiersTypeMap, Type};

let mut id_map = HashMap::new();
id_map.insert("value".to_string(), Type::Boolean);
let identifiers = IdentifiersTypeMap::from(id_map);

let functions = FunctionsTypeMap::from(HashMap::new());

let expr = Expr::Identifier("value".to_string());

assert_eq!(expr.are_types_valid(&identifiers, &functions), Ok(true));

pub fn validate( &self, identifiers: &IdentifiersTypeMap, functions: &FunctionsTypeMap, ) -> Result<Type, ValidationError>

Validates the types within the expression.

A Result which is Ok with the type of the expression if the types are valid, or an Err with a ValidationError if the types are not valid.

use std::collections::HashMap;
use odata_params::filters::{Expr, FunctionsTypeMap, IdentifiersTypeMap, Type};

let mut id_map = HashMap::new();
id_map.insert("value".to_string(), Type::Number);
let identifiers = IdentifiersTypeMap::from(id_map);

let mut func_map = HashMap::new();
func_map.insert(
    "sum".to_string(),
    (vec![Type::Number], None, Type::Number),
);
let functions = FunctionsTypeMap::from(func_map);

let expr = Expr::Function("sum".to_string(), vec![Expr::Identifier("value".to_string())]);

assert_eq!(expr.validate(&identifiers, &functions), Ok(Type::Number));

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

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

impl StructuralPartialEq for Expr