Enum MapKeyType

#[repr(u8)]
pub enum MapKeyType {
    Bool,
    Int,
    Uint,
    String,
    Dyn,
    TypeParam(TypeParamType),
}

Types that can be used as map keys.

CEL maps can only use certain types as keys. This enum represents the allowed key types in CEL map literals and map type definitions.

Examples

use cel_cxx::*;

// String keys are common
let string_key_map = MapType::new(MapKeyType::String, ValueType::Int);

// Integer keys are also supported
let int_key_map = MapType::new(MapKeyType::Int, ValueType::String);

// Check the kind of a key type
assert_eq!(MapKeyType::String.kind(), Kind::String);

Note

Not all CEL types can be used as map keys. Only primitive types that are hashable and comparable are allowed.

Variants

Bool

Boolean keys - true and false.

Int

Signed integer keys.

Uint

Unsigned integer keys.

String

String keys (most common).

Dyn

Dynamic key type - determined at runtime.

TypeParam(TypeParamType)

Type parameter key type - used in generic contexts.

Implementations

impl MapKeyType

pub fn kind(&self) -> Kind

Returns the kind of this map key type.

This provides the basic category of the key type for type checking and dispatch purposes.

Examples

use cel_cxx::*;

assert_eq!(MapKeyType::String.kind(), Kind::String);
assert_eq!(MapKeyType::Int.kind(), Kind::Int);
assert_eq!(MapKeyType::Bool.kind(), Kind::Bool);

Trait Implementations

impl Clone for MapKeyType

fn clone(&self) -> MapKeyType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MapKeyType

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

Formats the value using the given formatter.

impl Display for MapKeyType

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

Formats the value using the given formatter.

impl From<MapKeyType> for ValueType

fn from(key: MapKeyType) -> Self

Converts to this type from the input type.

impl Hash for MapKeyType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MapKeyType

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<ValueType> for MapKeyType

type Error = InvalidMapKeyType

The type returned in the event of a conversion error.

fn try_from(value: ValueType) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for MapKeyType

impl StructuralPartialEq for MapKeyType