Struct BindContext 

pub struct BindContext<'a> { /* private fields */ }

Bindings context for a cel evaluation.

This struct houses all of the bindings (dynamic values) for a cel evaluation. Currently the types of identifiers that can be bound to are variables, functions and macros. This context is separate from the contents of the CelContext to allow for multiple runs with different bound values on the same programs without the need to maintain multiple copies of the programs.

Implementations

impl<'a> BindContext<'a>

pub fn new() -> BindContext<'a>

Create a new bind context contain default functions and macros.

Examples found in repository

examples/bench.rs (line 30)

fn bench_run_one_nobindings() {
    let mut cel = CelContext::new();
    let exec = BindContext::new();

    cel.add_program_str("entry", "((4 * 3) - 4) + 3").unwrap();

    cel.exec("entry", &exec).unwrap();
}

fn bench_run_many_no_bindings() {
    let mut cel = CelContext::new();
    let exec = BindContext::new();

    cel.add_program_str("entry", "((4 * 3) - 4) + 3").unwrap();

    for _ in 0..10_000 {
        cel.exec("entry", &exec).unwrap();
    }
}

fn bench_run_one_with_binding() {
    let mut cel = CelContext::new();
    let mut exec = BindContext::new();

    cel.add_program_str("entry", "((4 * 3) - foo) + 3").unwrap();
    exec.bind_param("foo", 6.into());

    cel.exec("entry", &exec).unwrap();
}

fn bench_run_one_with_many_bindings() {
    let mut cel = CelContext::new();
    let mut exec = BindContext::new();

    cel.add_program_str("entry", "((4 * 3) - foo) + 3").unwrap();

    for o in 0..10_000 {
        exec.bind_param("foo", o.into());

        cel.exec("entry", &exec).unwrap();
    }
}

fn bench_build_many() {
    let mut cel = CelContext::new();

    for o in 0..1_000 {
        cel.add_program_str(&format!("prog{}", o), &format!("((4 * 3) - {}) + 3", o))
            .unwrap();
    }
}

fn bench_construct_many_with_bindings() {
    for o in 0..10_000 {
        let mut cel = CelContext::new();
        let mut exec = BindContext::new();

        cel.add_program_str("entry", "((4 * 3) - foo) + 3").unwrap();
        exec.bind_param("foo", o.into());

        cel.exec("entry", &exec).unwrap();
    }
}

examples/explain.rs (line 90)

fn eval(source: &str, bindings: &serde_json::Value) -> CelResult<CelValue> {
    let mut ctx = CelContext::new();

    ctx.add_program_str("main", source)?;

    let mut bind = BindContext::new();
    bind.bind_params_from_json_obj(bindings.clone())?;

    Ok(ctx.exec("main", &bind)?)
}

examples/eval.rs (line 7)

fn main() {
    let args: Vec<String> = env::args().collect();
    let mut context = CelContext::new();
    let mut exec = BindContext::new();

    context.add_program_str("prog", &args[1]).unwrap();

    if args.len() > 2 {
        exec.bind_params_from_json_obj(args[2].parse().unwrap())
            .unwrap();
    }

    let res = context.exec("prog", &exec).unwrap();
    println!("{}", res);
}

pub fn for_compile() -> BindContext<'a>

pub fn bind_param(&mut self, name: &str, value: CelValue)

Bind a param with the given name and value.

Examples found in repository

examples/bench.rs (line 53)

fn bench_run_one_with_binding() {
    let mut cel = CelContext::new();
    let mut exec = BindContext::new();

    cel.add_program_str("entry", "((4 * 3) - foo) + 3").unwrap();
    exec.bind_param("foo", 6.into());

    cel.exec("entry", &exec).unwrap();
}

fn bench_run_one_with_many_bindings() {
    let mut cel = CelContext::new();
    let mut exec = BindContext::new();

    cel.add_program_str("entry", "((4 * 3) - foo) + 3").unwrap();

    for o in 0..10_000 {
        exec.bind_param("foo", o.into());

        cel.exec("entry", &exec).unwrap();
    }
}

fn bench_build_many() {
    let mut cel = CelContext::new();

    for o in 0..1_000 {
        cel.add_program_str(&format!("prog{}", o), &format!("((4 * 3) - {}) + 3", o))
            .unwrap();
    }
}

fn bench_construct_many_with_bindings() {
    for o in 0..10_000 {
        let mut cel = CelContext::new();
        let mut exec = BindContext::new();

        cel.add_program_str("entry", "((4 * 3) - foo) + 3").unwrap();
        exec.bind_param("foo", o.into());

        cel.exec("entry", &exec).unwrap();
    }
}

pub fn bind_params_from_json_obj(&mut self, values: Value) -> CelResult<()>

Cheater function to bind the keys of an JSON object with its values

Examples found in repository

examples/explain.rs (line 91)

fn eval(source: &str, bindings: &serde_json::Value) -> CelResult<CelValue> {
    let mut ctx = CelContext::new();

    ctx.add_program_str("main", source)?;

    let mut bind = BindContext::new();
    bind.bind_params_from_json_obj(bindings.clone())?;

    Ok(ctx.exec("main", &bind)?)
}

examples/eval.rs (line 12)

fn main() {
    let args: Vec<String> = env::args().collect();
    let mut context = CelContext::new();
    let mut exec = BindContext::new();

    context.add_program_str("prog", &args[1]).unwrap();

    if args.len() > 2 {
        exec.bind_params_from_json_obj(args[2].parse().unwrap())
            .unwrap();
    }

    let res = context.exec("prog", &exec).unwrap();
    println!("{}", res);
}

pub fn bind_param_proto_msg(&mut self, name: &str, msg: Box<dyn MessageDyn>)

pub fn bind_func(&mut self, name: &str, func: &'a RsCelFunction)

Bind a function to the bind context, can be new or overwrite an existing (including default)

pub fn bind_macro(&mut self, name: &str, macro_: &'a RsCelMacro)

Bind a macro to the bind context.

pub fn get_param<'l>(&'l self, name: &str) -> Option<&'l CelValue>

Get a param by name.

pub fn get_func(&self, name: &str) -> Option<&'a RsCelFunction>

Get a function by name.

pub fn get_macro(&self, name: &str) -> Option<&'a RsCelMacro>

Get a macro by name.

pub fn is_bound(&self, name: &str) -> bool

Trait Implementations

impl<'a> Clone for BindContext<'a>

fn clone(&self) -> BindContext<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.