Struct Node

Source

pub struct Node<NumericTypes: EvalexprNumericTypes = DefaultNumericTypes> { /* private fields */ }

Expand description

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 evalexpr::*;

let mut context = HashMapContext::<DefaultNumericTypes>::new();
context.set_value("alpha".into(), Value::from_int(2)).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_int(3)));

Implementations§

Source §

impl<NumericTypes: EvalexprNumericTypes> Node<NumericTypes>

Source

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

Returns an iterator over all nodes in this tree.

Source

pub fn iter_operators_mut( &mut self, ) -> impl Iterator<Item = &mut Operator<NumericTypes>>

Returns a mutable iterator over all operators in this tree.

Source §

impl<NumericTypes: EvalexprNumericTypes> Node<NumericTypes>

Source

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 evalexpr::*;

let tree = build_operator_tree::<DefaultNumericTypes>("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);

Source

pub fn iter_identifiers_mut(&mut self) -> impl Iterator<Item = &mut String>

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

§Examples

use evalexpr::*;

let mut tree = build_operator_tree::<DefaultNumericTypes>("a + b + c * f()").unwrap(); // Do proper error handling here

for identifier in tree.iter_identifiers_mut() {
    *identifier = String::from("x");
}

let mut iter = tree.iter_identifiers();

assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), None);

Source

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 evalexpr::*;

let tree = build_operator_tree::<DefaultNumericTypes>("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);

Source

pub fn iter_variable_identifiers_mut( &mut self, ) -> impl Iterator<Item = &mut String>

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

§Examples

use evalexpr::*;

let mut tree = build_operator_tree::<DefaultNumericTypes>("a + b + c * f()").unwrap(); // Do proper error handling here

for identifier in tree.iter_variable_identifiers_mut() {
    *identifier = String::from("x");
}

let mut iter = tree.iter_identifiers();

assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("f"));
assert_eq!(iter.next(), None);

Source

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 evalexpr::*;

let tree = build_operator_tree::<DefaultNumericTypes>("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);

Source

pub fn iter_read_variable_identifiers_mut( &mut self, ) -> impl Iterator<Item = &mut String>

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

§Examples

use evalexpr::*;

let mut tree = build_operator_tree::<DefaultNumericTypes>("d = a + f(b + c)").unwrap(); // Do proper error handling here

for identifier in tree.iter_read_variable_identifiers_mut() {
    *identifier = String::from("x");
}

let mut iter = tree.iter_identifiers();

assert_eq!(iter.next(), Some("d"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("f"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), None);

Source

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 evalexpr::*;

let tree = build_operator_tree::<DefaultNumericTypes>("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);

Source

pub fn iter_write_variable_identifiers_mut( &mut self, ) -> impl Iterator<Item = &mut String>

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

§Examples

use evalexpr::*;

let mut tree = build_operator_tree::<DefaultNumericTypes>("d = a + f(b + c)").unwrap(); // Do proper error handling here

for identifier in tree.iter_write_variable_identifiers_mut() {
    *identifier = String::from("x");
}

let mut iter = tree.iter_identifiers();

assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("a"));
assert_eq!(iter.next(), Some("f"));
assert_eq!(iter.next(), Some("b"));
assert_eq!(iter.next(), Some("c"));
assert_eq!(iter.next(), None);

Source

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 evalexpr::*;

let tree = build_operator_tree::<DefaultNumericTypes>("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);

Source

pub fn iter_function_identifiers_mut( &mut self, ) -> impl Iterator<Item = &mut String>

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

§Examples

use evalexpr::*;

let mut tree = build_operator_tree::<DefaultNumericTypes>("d = a + f(b + c)").unwrap(); // Do proper error handling here

for identifier in tree.iter_function_identifiers_mut() {
    *identifier = String::from("x");
}

let mut iter = tree.iter_identifiers();

assert_eq!(iter.next(), Some("d"));
assert_eq!(iter.next(), Some("a"));
assert_eq!(iter.next(), Some("x"));
assert_eq!(iter.next(), Some("b"));
assert_eq!(iter.next(), Some("c"));
assert_eq!(iter.next(), None);

Source