Enum LogicalExpression

pub enum LogicalExpression<Condition> {
    And(Vec<LogicalExpression<Condition>>),
    Or(Vec<LogicalExpression<Condition>>),
    Condition(Condition),
}

Represents a logical expression with conditions combined using AND and OR operators.

Variants

And(Vec<LogicalExpression<Condition>>)

Represents a logical AND operation on a list of logical expressions.

Or(Vec<LogicalExpression<Condition>>)

Represents a logical OR operation on a list of logical expressions.

Condition(Condition)

Represents a single condition in the logical expression.

Implementations

impl<C: FromStr> LogicalExpression<C>

pub fn parse(s: &str) -> Result<Self, ParseError<<C as FromStr>::Err>>

Parses a logical expression from a string.

Returns a Result containing the parsed LogicalExpression if successful, or a ParseError if an error occurred during parsing.

Examples found in repository

examples/example.rs (line 4)

fn main() {
    let expression: LogicalExpression<String> = LogicalExpression::parse("a & (b | c)").unwrap();
    let expanded = expression.expand();
    println!("{expanded:?}");
}

impl<C> LogicalExpression<C>

pub fn parse_with<F, E>( s: &str, parse_condition: F, ) -> Result<Self, ParseError<E>>

where F: FnMut(&str) -> Result<C, E>,

Parses a logical expression from a string using a custom parsing function.

The parse_condition function is used to parse individual conditions from string slices.

Returns a Result containing the parsed LogicalExpression if successful, or a ParseError if an error occurred during parsing.

pub fn parse_with_expression<F, E>( s: &str, parse_expression: F, ) -> Result<Self, ParseError<E>>

where F: FnMut(&str) -> Result<Self, E>,

Parses a logical expression from a string using a custom parsing function.

The parse_expression function is used to parse individual conditions from string slices into expressions.

Returns a Result containing the parsed LogicalExpression if successful, or a ParseError if an error occurred during parsing.

impl<Condition> LogicalExpression<Condition>

pub fn and(list: Vec<Self>) -> Self

Creates a new logical expression representing the logical AND of the given list of expressions.

If the list contains only one expression, it is returned as is.

pub fn or(list: Vec<Self>) -> Self

Creates a new logical expression representing the logical OR of the given list of expressions.

If the list contains only one expression, it is returned as is.

impl<Condition: Clone> LogicalExpression<Condition>

pub fn expand(self) -> Vec<Vec<Condition>>

Expands the logical expression into a list of lists, where the inner lists represent the AND conditions and the outer lists represent the OR conditions.

Examples found in repository

examples/example.rs (line 5)

fn main() {
    let expression: LogicalExpression<String> = LogicalExpression::parse("a & (b | c)").unwrap();
    let expanded = expression.expand();
    println!("{expanded:?}");
}

Trait Implementations

impl<Condition: Clone> Clone for LogicalExpression<Condition>

fn clone(&self) -> LogicalExpression<Condition>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Condition: Debug> Debug for LogicalExpression<Condition>

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

Formats the value using the given formatter.

impl<Condition: PartialEq> PartialEq for LogicalExpression<Condition>

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

impl<Condition> StructuralPartialEq for LogicalExpression<Condition>