Struct MapType

pub struct MapType {
    pub key: MapKeyType,
    pub value: Box<ValueType>,
}

Map type representing key-value mappings.

Map types specify both the type of keys and the type of values. Not all types can be used as map keys - only certain primitive types are allowed.

Examples

use cel_cxx::*;

// Map from string to int: map<string, int>
let string_to_int = MapType::new(MapKeyType::String, ValueType::Int);

// Map from int to list of strings: map<int, list<string>>
let complex_map = MapType::new(
    MapKeyType::Int,
    ValueType::List(ListType::new(ValueType::String))
);

Fields

key: MapKeyType

The type of keys in this map.

value: Box<ValueType>

The type of values in this map.

Implementations

impl MapType

pub fn new(key: MapKeyType, value: ValueType) -> Self

Creates a new map type with the given key and value types.

Arguments

• key - The type of keys in the map
• value - The type of values in the map

Examples

use cel_cxx::*;

let map_type = MapType::new(MapKeyType::String, ValueType::Int);
assert_eq!(map_type.key(), &MapKeyType::String);
assert_eq!(map_type.value(), &ValueType::Int);

pub fn key(&self) -> &MapKeyType

Returns the key type of this map.

Examples

use cel_cxx::*;

let map_type = MapType::new(MapKeyType::Int, ValueType::String);
assert_eq!(map_type.key(), &MapKeyType::Int);

pub fn value(&self) -> &ValueType

Returns the value type of this map.

Examples

use cel_cxx::*;

let map_type = MapType::new(MapKeyType::String, ValueType::Double);
assert_eq!(map_type.value(), &ValueType::Double);

Trait Implementations

impl Clone for MapType

fn clone(&self) -> MapType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MapType

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

Formats the value using the given formatter.

impl Display for MapType

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

Formats the value using the given formatter.

impl From<MapType> for ValueType

fn from(value: MapType) -> Self

Converts to this type from the input type.

impl Hash for MapType

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 MapType

fn eq(&self, other: &MapType) -> 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 Eq for MapType

impl StructuralPartialEq for MapType