Struct ResolvedLeafType 

pub struct ResolvedLeafType { /* private fields */ }

One resolved scalar leaf type.

This pairs a human-readable type name with complete canonical leaf metadata. Hosts use [ValueType::cloneable_leaf] when this leaf may also appear in a closure annotation; the same descriptor then supplies its checked argument-cloning adapter.

Concrete element factories retain complete metadata. Use Self::with_complete_value_type to enrich its optional capabilities; metadata cannot be recovered from a TypeId. Equality compares registered identity, not optional capability availability.

Implementations

impl ResolvedLeafType

pub fn leaf<T: 'static>(type_name: impl Into<Cow<'static, str>>) -> Result<Self>

Registers an opaque concrete host leaf without optional capabilities.

Foreign types require no trait implementation or wrapper.

Errors

Rejects an erased whole-value owner, which is not a concrete CEL leaf.

• Complexity: O(l) time and space for a source-facing name of length l.

Examples

use cel_parser::ResolvedLeafType;
let leaf = ResolvedLeafType::leaf::<std::path::PathBuf>("Path").unwrap();
assert!(leaf.complete_value_type().is_ok());

pub fn new( type_name: impl Into<Cow<'static, str>>, element_type: ValueType, ) -> Self

Creates one resolved leaf from a user-facing type name and runtime element descriptor.

The descriptor adopts type_name, so a runtime mismatch diagnostic against this leaf reports the name the source annotation (or the host’s registry) uses rather than [ValueType::leaf]’s Rust type path.

• Postcondition: the returned leaf’s type_id matches element_type, and its element_type reports type_name.
• Precondition: element_type describes a concrete opaque leaf.
• Complexity: O(l) for name length l.

Examples

let leaf = cel_parser::ResolvedLeafType::new("Integer", cel_runtime::ValueType::leaf::<i32>());
assert_eq!(leaf.type_name(), "Integer");

pub fn with_complete_value_type(self, complete: ValueType) -> Result<Self>

Attaches a complete leaf descriptor built while its concrete type was known.

Optional capabilities are retained unchanged and independently; attaching metadata emits no interpreter instructions.

Errors

Returns an error if either descriptor is structural or concrete identity or layout differs.

Examples

use cel_parser::ResolvedLeafType;
use cel_runtime::value_type::ValueType;
let leaf = ResolvedLeafType::leaf::<String>("Text").unwrap()
    .with_complete_value_type(ValueType::cloneable_leaf::<String>()).unwrap();
assert!(leaf.complete_value_type().is_ok());

pub fn complete_value_type(&self) -> Result<&ValueType>

Borrows complete registration-time metadata without inventing erased adapters.

Errors

Rejects an erased whole-value owner, which cannot be a registered leaf.

Examples

use cel_parser::ResolvedLeafType;
assert!(ResolvedLeafType::leaf::<()>("HostUnit").unwrap()
    .complete_value_type().is_ok());

pub fn type_id(&self) -> TypeId

Returns this leaf type’s concrete Rust TypeId.

pub fn type_name(&self) -> &str

Returns this leaf type’s human-readable name.

pub fn element_type(&self) -> &ValueType

Returns complete canonical metadata for this leaf.

Trait Implementations

impl Clone for ResolvedLeafType

fn clone(&self) -> ResolvedLeafType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedLeafType

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

Formats the value using the given formatter.

impl Eq for ResolvedLeafType

impl From<ResolvedLeafType> for ResolvedType

fn from(leaf: ResolvedLeafType) -> Self

Promotes a registered leaf without changing its identity.

impl PartialEq for ResolvedLeafType

fn eq(&self, other: &Self) -> bool

Compares registered leaf identities independently of optional capabilities.

• Complexity: O(l) for name length l.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.