Struct Tree

pub struct Tree<T> { /* private fields */ }

A compound node in a filter expression, consisting of a logical operator and a set of child expressions.

Implementations

impl<T> Tree<T>

pub fn new(operator: Logic, rules: Vec<T>) -> Self

pub fn operator(&self) -> Logic

pub fn rules(&self) -> &[T]

Examples found in repository

examples/schema_validation.rs (line 111)

    fn visit_tree(&mut self, tree: &'ast Tree<Expr<Field, Operator, String>>) {
        for (idx, rule) in tree.rules().iter().enumerate() {
            self.current_path.push(idx);
            self.visit_expr(rule);
            self.current_path.pop();
        }
    }

pub fn into_tuple(self) -> (Logic, Vec<T>)

Decompose the tree into its operator and rules.

pub fn from_iter(operator: Logic, rules: impl Iterator<Item = T>) -> Self

Create an instance by collecting the rules from an iterator.

Example

let rules = vec![
    Clause::new("name", "=", "jim"),
    Clause::new("age", ">", "10")
];

let tree = Tree::from_iter(
    Logic::And,
    rules.into_iter().filter(|f| *f.field() != "age")
);

assert_eq!(1, tree.rules().len());

pub fn map<U, F>(self, transform: F) -> Tree<U>

where F: FnMut(T) -> U,

Create a new tree by applying a transform to all its rules.

Example

let tree = Tree::new(Logic::Or, vec![1, 2]);
let tree2 = tree.map(|x| x * 10);
assert_eq!(Tree::new(Logic::Or, vec![10, 20]), tree2);

pub fn try_map<U, E, F>(self, transform: F) -> Result<Tree<U>, E>

where F: FnMut(T) -> Result<U, E>,

Create a new tree by applying a fallible transform to all its rules. The function will return the first error it encounters.

Example

let tree = Tree::new(Logic::Or, vec![1, 2]);
let tree2 = tree.try_map(|x| {
    if x % 2 == 0 {
        Ok(x * 10)
    } else {
        Err(format!("Odd number: {}", x))
    }
});
assert_eq!("Odd number: 1", &tree2.unwrap_err());

impl<T: Ord> Tree<T>

pub fn sort(&mut self)

Sort the rules in the tree.

Trait Implementations

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

type Output = Expr<F, P, O>

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<Tree<Expr<F, P, O>>> for Expr<F, P, O>

type Output = Expr<F, P, O>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T: Clone> Clone for Tree<T>

fn clone(&self) -> Tree<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Tree<T>

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Tree<T>

fn eq(&self, other: &Tree<T>) -> 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<T: Eq> Eq for Tree<T>

impl<T> StructuralPartialEq for Tree<T>