Enum filter_ast::Expr

pub enum Expr<F, P, O> {
    Tree(Tree<Expr<F, P, O>>),
    Clause(Clause<F, P, O>),
}

A filter expression.

Filter expressions are an abstract representation of a function (val: T) -> bool.

Variants

Tree(Tree<Expr<F, P, O>>)

A sub-tree in the filter expression.

Tuple Fields of Tree

0: Tree<Expr<F, P, O>>

Clause(Clause<F, P, O>)

A leaf node in the filter expression.

Tuple Fields of Clause

0: Clause<F, P, O>

Implementations

impl<F, P, O> Expr<F, P, O>

pub fn new_clause(field: F, operator: P, operand: O) -> Self

Create a new clause wrapped in an Expr.

pub fn is_tree(&self) -> bool

pub fn is_clause(&self) -> bool

pub fn as_tree(&self) -> Option<&Tree<Expr<F, P, O>>>

pub fn as_clause(&self) -> Option<&Clause<F, P, O>>

pub fn map_ref<'ast, F2, P2, O2, TF>(
    &'ast self,
    transform: TF
) -> Expr<F2, P2, O2> where
    TF: FnMut(&'ast Clause<F, P, O>) -> Expr<F2, P2, O2>, 

Apply a mapping function to a reference to each clause in the expression, creating a new expression without consuming the original.

pub fn map<F2, P2, O2, TF>(self, transform: TF) -> Expr<F2, P2, O2> where
    TF: FnMut(Clause<F, P, O>) -> Expr<F2, P2, O2>, 

Apply a mapping function to each clause in the expression, creating a new expression.

The mapping function is allowed to return a new tree; this enables expansion of one clause into a nested sub-tree.

For a non-consuming version of this function, see Expr::map_ref.

pub fn try_map_ref<'ast, F2, P2, O2, E, TF>(
    &'ast self,
    transform: TF
) -> Result<Expr<F2, P2, O2>, E> where
    TF: FnMut(&'ast Clause<F, P, O>) -> Result<Expr<F2, P2, O2>, E>, 

Apply a fallible mapping function to each clause in the expression, returning a new expression or the first error encountered. The input expression is not consumed.

This function enables fail-fast validation and adaptation of an expression.

A major use-case for try_map_ref is schema validation: F, P, and O each represent the union of possible values in their respective positions but not all permutations are valid: A field called last_seen might not accept an IpAddr operand.

The other main use-case for try_map_ref is secondary parsing. If two operand types both serialize to strings, then deserialization cannot immediately choose the right operand type. Guessing wrong could introduce strange errors; it would be bad if a caller could break filtering by choosing a resource name that looked like an IP address. In that scenario, deserialization would read the field and operator into their semantic types, while preserving the operand as seen on the wire. Then try_map_ref would be used to finish parsing, with the operand interpretation being chosen based on the field and operator.

pub fn try_map<F2, P2, O2, E, TF>(
    self,
    transform: TF
) -> Result<Expr<F2, P2, O2>, E> where
    TF: FnMut(Clause<F, P, O>) -> Result<Expr<F2, P2, O2>, E>, 

Apply a fallible mapping function to each clause in the expression, returning a new expression or the first error encountered.

This function enables fail-fast validation and adaptation of an expression.

A major use-case for try_map is schema validation: F, P, and O each represent the union of possible values in their respective positions but not all permutations are valid: A field called last_seen might not accept an IpAddr operand.

The other main use-case for try_map is secondary parsing. If two operand types both serialize to strings, then deserialization cannot immediately choose the right operand type. Guessing wrong could introduce strange errors; it would be bad if a caller could break filtering by choosing a resource name that looked like an IP address. In that scenario, deserialization would read the field and operator into their semantic types, while preserving the operand as seen on the wire. Then try_map would be used to finish parsing, with the operand interpretation being chosen based on the field and operator.

For a non-consuming version of this function, see Expr::try_map_ref.

pub fn clauses(&self) -> Clauses<'_, F, P, O>

Visit all clauses in depth-first order.

For more advanced visiting, see visit::Visit.

Trait Implementations

impl<F, P, O> BitAnd<Clause<F, P, O>> for Expr<F, P, O>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Clause<F, P, O>) -> Self::Output

Performs the & operation.

impl<F, P, O> BitAnd<Expr<F, P, O>> for Expr<F, P, O>

Create a new expression representing the intersection of the provided expressions.

Usage

let a = Expr::new_clause("field", "=", "v1");
let b = Expr::new_clause("other", "=", "a");
let c = a & b;
let c_tree = c.as_tree().unwrap();
assert_eq!(c_tree.operator(), Logic::And);
assert_eq!(c_tree.rules()[0].as_clause().unwrap().field(), &"field");
assert_eq!(c_tree.rules()[1].as_clause().unwrap().field(), &"other");

Tree Simplification

This operation will try to avoid increasing tree depth by merging rules from input tree expressions whose operator is Logic::And. For example, (a & b) & (c & d & e) will produce a & b & c & d & e.

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<F, P, O> BitAnd<Tree<Expr<F, P, O>>> for Expr<F, P, O>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Tree<Expr<F, P, O>>) -> Self::Output

Performs the & operation.

impl<F, P, O> BitOr<Clause<F, P, O>> for Expr<F, P, O>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Clause<F, P, O>) -> Self::Output

Performs the | operation.

impl<F, P, O> BitOr<Expr<F, P, O>> for Expr<F, P, O>

Create a new expression representing the union of the provided expressions.

Usage

let a = Expr::new_clause("field", "=", "v1");
let b = Expr::new_clause("other", "=", "a");
let c = a | b;
let c_tree = c.as_tree().unwrap();
assert_eq!(c_tree.operator(), Logic::Or);
assert_eq!(c_tree.rules()[0].as_clause().unwrap().field(), &"field");
assert_eq!(c_tree.rules()[1].as_clause().unwrap().field(), &"other");

Tree Simplification

This operation will try to avoid increasing tree depth by merging rules from input tree expressions whose operator is Logic::And. For example, (a | b) | (c | d | e) will produce a | b | c | d | e.

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<F, P, O> BitOr<Tree<Expr<F, P, O>>> for Expr<F, P, O>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Tree<Expr<F, P, O>>) -> Self::Output

Performs the | operation.

impl<F: Clone, P: Clone, O: Clone> Clone for Expr<F, P, O>

fn clone(&self) -> Expr<F, P, O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug, P: Debug, O: Debug> Debug for Expr<F, P, O>

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

Formats the value using the given formatter.

impl<F, P, O> From<Clause<F, P, O>> for Expr<F, P, O>

fn from(v: Clause<F, P, O>) -> Self

Performs the conversion.

impl<F, P, O> From<Tree<Expr<F, P, O>>> for Expr<F, P, O>

fn from(v: Tree<Expr<F, P, O>>) -> Self

Performs the conversion.

impl<F, P, O> Not for Expr<F, P, O>

Create a new expression representing the inverse of the provided expression.

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.