Struct ExprNode

pub struct ExprNode { /* private fields */ }

A node in the operator tree. The operator tree is created by the crate-level build_operator_tree method. It can be evaluated for a given context with the Node::eval method.

The advantage of constructing the operator tree separately from the actual evaluation is that it can be evaluated arbitrarily often with different contexts.

Examples

use fastn_resolved::evalexpr::*;

let mut context = HashMapContext::new();
context.set_value("alpha".into(), 2.into()).unwrap(); // Do proper error handling here
let node = build_operator_tree("1 + alpha").unwrap(); // Do proper error handling here
assert_eq!(node.eval_with_context(&context), Ok(Value::from(3)));

Implementations

impl ExprNode

pub fn iter(&self) -> impl Iterator<Item = &ExprNode>

Returns an iterator over all nodes in this tree.

impl ExprNode

pub fn new(operator: Operator) -> Self

Return a node object

pub fn add_children(self, children: Vec<ExprNode>) -> Self

Adds the children in node

pub fn iter_identifiers(&self) -> impl Iterator<Item = &str>

Returns an iterator over all identifiers in this expression. Each occurrence of an identifier is returned separately.

Examples

use fastn_resolved::evalexpr::*;

let tree = build_operator_tree("a + b + c * f()").unwrap(); // Do proper error handling here
let mut iter = tree.iter_identifiers();
assert_eq!(iter.next(), Some("a"));
assert_eq!(iter.next(), Some("b"));
assert_eq!(iter.next(), Some("c"));
assert_eq!(iter.next(), Some("f"));
assert_eq!(iter.next(), None);

pub fn iter_variable_identifiers(&self) -> impl Iterator<Item = &str>

Returns an iterator over all variable identifiers in this expression. Each occurrence of a variable identifier is returned separately.

Examples

use fastn_resolved::evalexpr::*;

let tree = build_operator_tree("a + f(b + c)").unwrap(); // Do proper error handling here
let mut iter = tree.iter_variable_identifiers();
assert_eq!(iter.next(), Some("a"));
assert_eq!(iter.next(), Some("b"));
assert_eq!(iter.next(), Some("c"));
assert_eq!(iter.next(), None);

pub fn iter_read_variable_identifiers(&self) -> impl Iterator<Item = &str>

Returns an iterator over all read variable identifiers in this expression. Each occurrence of a variable identifier is returned separately.

Examples

use fastn_resolved::evalexpr::*;

let tree = build_operator_tree("d = a + f(b + c)").unwrap(); // Do proper error handling here
let mut iter = tree.iter_read_variable_identifiers();
assert_eq!(iter.next(), Some("a"));
assert_eq!(iter.next(), Some("b"));
assert_eq!(iter.next(), Some("c"));
assert_eq!(iter.next(), None);

pub fn iter_write_variable_identifiers(&self) -> impl Iterator<Item = &str>

Returns an iterator over all write variable identifiers in this expression. Each occurrence of a variable identifier is returned separately.

Examples

use fastn_resolved::evalexpr::*;

let tree = build_operator_tree("d = a + f(b + c)").unwrap(); // Do proper error handling here
let mut iter = tree.iter_write_variable_identifiers();
assert_eq!(iter.next(), Some("d"));
assert_eq!(iter.next(), None);

pub fn iter_function_identifiers(&self) -> impl Iterator<Item = &str>

Returns an iterator over all function identifiers in this expression. Each occurrence of a function identifier is returned separately.

Examples

use fastn_resolved::evalexpr::*;

let tree = build_operator_tree("a + f(b + c)").unwrap(); // Do proper error handling here
let mut iter = tree.iter_function_identifiers();
assert_eq!(iter.next(), Some("f"));
assert_eq!(iter.next(), None);

pub fn eval_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<Value>

Evaluates the operator tree rooted at this node with the given context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<Value>

Evaluates the operator tree rooted at this node with the given mutable context.

Fails, if one of the operators in the expression tree fails.

pub fn eval(&self) -> EvalexprResult<Value>

Evaluates the operator tree rooted at this node.

Fails, if one of the operators in the expression tree fails.

pub fn eval_string_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<String>

Evaluates the operator tree rooted at this node into a string with an the given context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_float_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<FloatType>

Evaluates the operator tree rooted at this node into a float with an the given context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_int_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<IntType>

Evaluates the operator tree rooted at this node into an integer with an the given context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_number_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<FloatType>

Evaluates the operator tree rooted at this node into a float with an the given context. If the result of the expression is an integer, it is silently converted into a float.

Fails, if one of the operators in the expression tree fails.

pub fn eval_boolean_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<bool>

Evaluates the operator tree rooted at this node into a boolean with an the given context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_tuple_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<TupleType>

Evaluates the operator tree rooted at this node into a tuple with an the given context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_empty_with_context<C: Context>( &self, context: &C, ) -> EvalexprResult<EmptyType>

Evaluates the operator tree rooted at this node into an empty value with an the given context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_string_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<String>

Evaluates the operator tree rooted at this node into a string with an the given mutable context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_float_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<FloatType>

Evaluates the operator tree rooted at this node into a float with an the given mutable context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_int_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<IntType>

Evaluates the operator tree rooted at this node into an integer with an the given mutable context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_number_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<FloatType>

Evaluates the operator tree rooted at this node into a float with an the given mutable context. If the result of the expression is an integer, it is silently converted into a float.

Fails, if one of the operators in the expression tree fails.

pub fn eval_boolean_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<bool>

Evaluates the operator tree rooted at this node into a boolean with an the given mutable context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_tuple_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<TupleType>

Evaluates the operator tree rooted at this node into a tuple with an the given mutable context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_empty_with_context_mut<C: ContextWithMutableVariables>( &self, context: &mut C, ) -> EvalexprResult<EmptyType>

Evaluates the operator tree rooted at this node into an empty value with an the given mutable context.

Fails, if one of the operators in the expression tree fails.

pub fn eval_string(&self) -> EvalexprResult<String>

Evaluates the operator tree rooted at this node into a string.

Fails, if one of the operators in the expression tree fails.

pub fn eval_float(&self) -> EvalexprResult<FloatType>

Evaluates the operator tree rooted at this node into a float.

Fails, if one of the operators in the expression tree fails.

pub fn eval_int(&self) -> EvalexprResult<IntType>

Evaluates the operator tree rooted at this node into an integer.

Fails, if one of the operators in the expression tree fails.

pub fn eval_number(&self) -> EvalexprResult<FloatType>

Evaluates the operator tree rooted at this node into a float. If the result of the expression is an integer, it is silently converted into a float.

Fails, if one of the operators in the expression tree fails.

pub fn eval_boolean(&self) -> EvalexprResult<bool>

Evaluates the operator tree rooted at this node into a boolean.

Fails, if one of the operators in the expression tree fails.

pub fn eval_tuple(&self) -> EvalexprResult<TupleType>

Evaluates the operator tree rooted at this node into a tuple.

Fails, if one of the operators in the expression tree fails.

pub fn eval_empty(&self) -> EvalexprResult<EmptyType>

Evaluates the operator tree rooted at this node into an empty value.

Fails, if one of the operators in the expression tree fails.

pub fn children(&self) -> &[ExprNode]

Returns the children of this node as a slice.

pub fn mut_children(&mut self) -> &mut [ExprNode]

Returns the children of this node as a mutable slice.

pub fn operator(&self) -> &Operator

Returns the operator associated with this node.

pub fn children_mut(&mut self) -> &mut Vec<ExprNode>

Returns a mutable reference to the vector containing the children of this node.

WARNING: Writing to this might have unexpected results, as some operators require certain amounts and types of arguments.

pub fn operator_mut(&mut self) -> &mut Operator

Returns a mutable reference to the operator associated with this node.

WARNING: Writing to this might have unexpected results, as some operators require different amounts and types of arguments.

Trait Implementations

impl Clone for ExprNode

fn clone(&self) -> ExprNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExprNode

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

Formats the value using the given formatter.

impl PartialEq for ExprNode

fn eq(&self, other: &ExprNode) -> 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 Serialize for ExprNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExprNode