Trait TypeResolver 

pub trait TypeResolver: Send + Sync {
    // Required method
    fn resolve_named_type(
        &self,
        name: &str,
        args: &[ResolvedType],
    ) -> Option<ResolvedLeafType>;
}

Resolves one named leaf type for CEL type expressions.

Implementations return None when name is unknown. Recursive array and tuple composition is performed by TypeExpr::resolve, so a resolver only needs to recognize leaf names.

Examples

use cel_parser::{TypeResolver, ResolvedLeafType};
let resolver = [("Count", ResolvedLeafType::leaf::<u32>("Count").unwrap())];
assert!(resolver.resolve_named_type("Count", &[]).is_some());
assert!(resolver.resolve_named_type("Missing", &[]).is_none());

Required Methods

fn resolve_named_type( &self, name: &str, args: &[ResolvedType], ) -> Option<ResolvedLeafType>

Returns the registered leaf type named name applying args (already resolved), or None if name/args is unrecognized. args is empty for a plain (non-generic) name.

Examples

See the TypeResolver example.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<const N: usize> TypeResolver for [(&'static str, ResolvedLeafType); N]

fn resolve_named_type( &self, name: &str, args: &[ResolvedType], ) -> Option<ResolvedLeafType>

Resolves an exact registered name only when no generic arguments are supplied.

• Complexity: O(N * b + c) for N names of at most b bytes and descriptor-copy cost c.

Implementors

impl<F> TypeResolver for F

where F: Fn(&str, &[ResolvedType]) -> Option<ResolvedLeafType> + Send + Sync,