Struct Expression 

pub struct Expression { /* private fields */ }

A parsed boolean expression over a JSON context.

See the module documentation for the grammar and the evaluation semantics. Serializes as its source string; deserializing parses the string and rejects invalid expressions. Two expressions are equal when their sources are equal.

Examples

use ironflow_engine::expression::Expression;
use serde_json::json;

let expr: Expression = "steps[\"risk-assessment\"].output.level == \"high\"".parse()?;
let ctx = json!({"steps": {"risk-assessment": {"output": {"level": "high"}}}});
assert!(expr.evaluate(&ctx));

Implementations

impl Expression

pub fn parse(src: &str) -> Result<Self, ExpressionError>

Parse an expression.

Errors

Returns an ExpressionError when the source is empty, too long, too deeply nested, lexically or syntactically invalid, or uses a path root outside EXPRESSION_ROOTS.

Examples

use ironflow_engine::expression::Expression;

let expr = Expression::parse("output.amount > 10000")?;
assert_eq!(expr.source(), "output.amount > 10000");
assert!(Expression::parse("output.amount >").is_err());

pub fn evaluate(&self, ctx: &Value) -> bool

Evaluate the expression against a JSON context.

Never fails: missing paths resolve to null and type mismatches evaluate to false.

Examples

use ironflow_engine::expression::Expression;
use serde_json::json;

let expr = Expression::parse("labels.priority > 3")?;
assert!(expr.evaluate(&json!({"labels": {"priority": "5"}})));
assert!(!expr.evaluate(&json!({"labels": {}})));

pub fn source(&self) -> &str

The source text the expression was parsed from.

Examples

use ironflow_engine::expression::Expression;

let expr = Expression::parse("payload.urgent")?;
assert_eq!(expr.source(), "payload.urgent");

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Self

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<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expression

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

Formats the value using the given formatter.

impl Eq for Expression

impl From<Expression> for String

fn from(expr: Expression) -> Self

Converts to this type from the input type.

impl FromStr for Expression

type Err = ExpressionError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Expression

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<String> for Expression

type Error = ExpressionError

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.