Struct Expression 

pub struct Expression { /* private fields */ }

Expression.

Expressions allow to build trees of Id and Selector instances combined with logical operators, enabling complex matching and filtering.

The following operators are supported:

• Expression::any: Logical OR - any operand must match.
• Expression::all: Logical AND - all operands must match.
• Expression::not: Logical NOT - no operand must match.

Examples

use zrx_id::{selector, Expression};

// Create expression
let expr = Expression::all(|expr| {
    expr.with(selector!(location = "**/*.md")?)?
        .with(Expression::not(|expr| {
            expr.with(selector!(provider = "file")?)
        })
    )
})?;

Implementations

impl Expression

pub fn any<F>(f: F) -> Result<Self>

where F: FnOnce(Builder) -> Result<Builder>,

Creates an expression for which any operand must match.

Errors

Returns Error::Id if any of the operands are invalid.

Examples

use zrx_id::{selector, Expression};

// Create expression
let expr = Expression::any(|expr| {
    expr.with(selector!(location = "**/*.jpg")?)?
        .with(selector!(location = "**/*.png")?)
})?;

pub fn all<F>(f: F) -> Result<Self>

where F: FnOnce(Builder) -> Result<Builder>,

Creates an expression for which all operands must match.

Errors

Returns Error::Id if any of the operands are invalid.

Examples

use zrx_id::{selector, Expression};

// Create expression
let expr = Expression::all(|expr| {
    expr.with(selector!(location = "**/*.md")?)?
        .with(selector!(provider = "file")?)
})?;

pub fn not<F>(f: F) -> Result<Self>

where F: FnOnce(Builder) -> Result<Builder>,

Creates an expression for which no operand must match.

Errors

Returns Error::Id if any of the operands are invalid.

Examples

use zrx_id::{selector, Expression};

// Create expression
let expr = Expression::all(|expr| {
    expr.with(selector!(location = "**/*.md")?)?
        .with(Expression::not(|expr| {
            expr.with(selector!(provider = "file")?)
        })
    )
})?;

impl Expression

pub fn operator(&self) -> Operator

Returns the operator.

pub fn operands(&self) -> &[Operand]

Returns a reference to the operands.

pub fn len(&self) -> usize

Returns the number of operands.

pub fn is_empty(&self) -> bool

Returns whether there are any operands.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate 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 Default for Expression

fn default() -> Self

Creates an expression that matches everything.

While it may seem counterintuitive to have the default expression match everything, it is designed this way to align with the concept of vacuous truth in logic. An expression with no operands is considered to be true, as there are no conditions to violate it.

In our implementation, we use an empty expression with a logical NOT operator to represent this concept, to be distinguishable as a marker.

Examples

use zrx_id::Expression;

// Create empty expression
let expr = Expression::default();
assert!(expr.is_empty());

impl From<Expression> for Operand

fn from(expr: Expression) -> Self

Creates an operand from an expression.

impl<T> From<T> for Expression

where T: Into<Term>,

fn from(term: T) -> Self

Creates an expression from a term.

impl IntoIterator for Expression

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator over the expression.

Examples

use zrx_id::{selector, Expression};

// Create expression
let expr = Expression::any(|expr| {
    expr.with(selector!(location = "**/*.jpg")?)?
        .with(selector!(location = "**/*.png")?)
})?;

// Create iterator over expression
for operand in expr {
    println!("{operand:?}");
}

type Item = Operand

The type of the elements being iterated over.

type IntoIter = IntoIter<<Expression as IntoIterator>::Item>

Which kind of iterator are we turning this into?

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

fn to_specificity(&self) -> Specificity

Computes the specificity of the expression.

Examples

use zrx_id::specificity::ToSpecificity;
use zrx_id::{selector, Expression};

// Create expression and compute specificity
let expr = Expression::any(|expr| {
    expr.with(selector!(location = "**/*.jpg")?)?
        .with(selector!(location = "**/*.png")?)
})?;
assert_eq!(expr.to_specificity(), (0, 1, 1, 4).into());

impl Eq for Expression

impl StructuralPartialEq for Expression