Enum cel_interpreter::context::Context

pub enum Context<'a> {
    Root {
        functions: FunctionRegistry,
        variables: HashMap<String, Value>,
    },
    Child {
        parent: &'a Context<'a>,
        variables: HashMap<String, Value>,
    },
}

Context is a collection of variables and functions that can be used by the interpreter to resolve expressions. The context can be either a parent context, or a child context. A parent context is created by default and contains all of the built-in functions. A child context can be created by calling .clone(). The child context has it’s own variables (which can be added to), but it will also reference the parent context. This allows for variables to be overridden within the child context while still being able to resolve variables in the child’s parents. You can have theoretically have an infinite number of child contexts that reference each-other.

So why is this important? Well some CEL-macros such as the .map macro declare intermediate user-specified identifiers that should only be available within the macro, and should not override variables in the parent context. The .map macro can clone the parent context, add the intermediate identifier to the child context, and then evaluate the map expression.

Intermediate variable stored in child context ↓ [1, 2, 3].map(x, x * 2) == [2, 4, 6] ↑ Only in scope for the duration of the map expression

Variants

Root

Fields

functions: FunctionRegistry

variables: HashMap<String, Value>

Child

Fields

parent: &'a Context<'a>

variables: HashMap<String, Value>

Implementations

impl<'a> Context<'a>

pub fn add_variable<S, V>( &mut self, name: S, value: V ) -> Result<(), Box<dyn Error>>

where S: Into<String>, V: TryIntoValue,

pub fn add_variable_from_value<S, V>(&mut self, name: S, value: V)

where S: Into<String>, V: Into<Value>,

pub fn get_variable<S>(&self, name: S) -> Result<Value, ExecutionError>

where S: Into<String>,

pub fn add_function<T: 'static, F>(&mut self, name: &str, value: F)

where F: Handler<T> + 'static,

pub fn resolve(&self, expr: &Expression) -> Result<Value, ExecutionError>

pub fn resolve_all(&self, exprs: &[Expression]) -> Result<Value, ExecutionError>

pub fn clone(&self) -> Context<'_>

Trait Implementations

impl<'a> Default for Context<'a>

fn default() -> Self

Returns the “default value” for a type.