Struct Env

pub struct Env<'f, Fm: FnMarker = (), Rm: RuntimeMarker = ()> { /* private fields */ }

CEL expression evaluation environment.

The Env struct represents a CEL environment that can compile expressions into programs. It encapsulates function registries, variable declarations, and type information needed for expression compilation.

Type Parameters

• 'f: Lifetime of functions registered in this environment
• Fm: Function marker type indicating sync/async function support
• Rm: Runtime marker type indicating the async runtime (if any)

Examples

Basic Usage

use cel_cxx::*;

let env = Env::builder()
    .declare_variable::<String>("name")?
    .build()?;
     
let program = env.compile("'Hello, ' + name")?;

With Custom Functions

use cel_cxx::*;

let env = Env::builder()
    .register_global_function("add", |x: i64, y: i64| -> i64 { x + y })?
    .build()?;
     
let program = env.compile("add(10, 20)")?;

Implementations

impl<'f> Env<'f>

pub fn builder() -> EnvBuilder<'f, ()>

Creates a new environment builder.

This is the starting point for creating a CEL environment. The builder allows you to register functions, declare variables, and configure the environment before building it.

Examples

use cel_cxx::*;

let builder = Env::builder();

impl<'f, Fm: FnMarker, Rm: RuntimeMarker> Env<'f, Fm, Rm>

pub fn compile<S: AsRef<[u8]>>( &self, source: S, ) -> Result<Program<'f, Fm, Rm>, Error>

Compiles a CEL expression into a Program.

This method takes a CEL expression as a string or byte slice and compiles it into a Program that can be evaluated with different activations.

Arguments

• source - The CEL expression to compile

Returns

Returns a Result containing the compiled Program or an Error if compilation fails.

Examples

use cel_cxx::*;

let env = Env::builder().build().unwrap();
let program = env.compile("1 + 2 * 3").unwrap();

Errors

Returns an error if:

• The expression contains syntax errors
• Referenced functions or variables are not declared
• Type checking fails

impl<'f, Rm: RuntimeMarker> Env<'f, (), Rm>

pub fn force_async(self) -> Env<'f, Async, Rm>

Available on crate feature async only.

Forces conversion to an async environment.

This method converts a synchronous environment to an asynchronous one, allowing it to work with async functions and evaluation.

Type Parameters

• Rt - The async runtime type to use

Examples

use cel_cxx::*;

let sync_env = Env::builder().build()?;
let async_env = sync_env.force_async();

impl<'f, Fm: FnMarker> Env<'f, Fm, ()>

pub fn use_runtime<Rt: Runtime>(self) -> Env<'f, Fm, Rt>

Available on crate feature async only.

Sets the async runtime for this environment.

This method specifies which async runtime should be used for asynchronous evaluation of expressions.

Type Parameters

• Rt - The runtime type to use (must implement Runtime)

Examples

use cel_cxx::*;

let env = Env::builder()
    .build()?
    .use_runtime::<Tokio>();

pub fn use_tokio(self) -> Env<'f, Fm, Tokio>

Available on crate features async and tokio only.

Configures the environment to use the Tokio async runtime.

This is a convenience method for setting the runtime to Tokio. Requires the tokio feature to be enabled.

Examples

use cel_cxx::*;

let env = Env::builder()
    .build()?
    .use_tokio();

pub fn use_async_std(self) -> Env<'f, Fm, AsyncStd>

Available on crate features async and async-std only.

Configures the environment to use the async-std runtime.

This is a convenience method for setting the runtime to async-std. Requires the async-std feature to be enabled.

Examples

use cel_cxx::*;

let env = Env::builder()
    .build()?
    .use_async_std();

pub fn use_smol(self) -> Env<'f, Fm, Smol>

Available on crate features async and smol only.

Configures the environment to use the smol runtime.

This is a convenience method for setting the runtime to smol. Requires the smol feature to be enabled.

Examples

use cel_cxx::*;

let env = Env::builder().use_smol();

Trait Implementations

impl<'f, Fm: FnMarker, Rm: RuntimeMarker> Clone for Env<'f, Fm, Rm>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'f, Fm: FnMarker, Rm: RuntimeMarker> Debug for Env<'f, Fm, Rm>

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

Formats the value using the given formatter.