pub trait Map: Reflect {
    // Required methods
    fn get(
        &self,
        key: &(dyn Reflect + 'static)
    ) -> Option<&(dyn Reflect + 'static)>;
    fn get_mut(
        &mut self,
        key: &(dyn Reflect + 'static)
    ) -> Option<&mut (dyn Reflect + 'static)>;
    fn get_at(
        &self,
        index: usize
    ) -> Option<(&(dyn Reflect + 'static), &(dyn Reflect + 'static))>;
    fn get_at_mut(
        &mut self,
        index: usize
    ) -> Option<(&(dyn Reflect + 'static), &mut (dyn Reflect + 'static))>;
    fn len(&self) -> usize;
    fn iter(&self) -> MapIter<'_> ;
    fn drain(self: Box<Self>) -> Vec<(Box<dyn Reflect>, Box<dyn Reflect>)>;
    fn clone_dynamic(&self) -> DynamicMap;
    fn insert_boxed(
        &mut self,
        key: Box<dyn Reflect>,
        value: Box<dyn Reflect>
    ) -> Option<Box<dyn Reflect>>;
    fn remove(
        &mut self,
        key: &(dyn Reflect + 'static)
    ) -> Option<Box<dyn Reflect>>;

    // Provided method
    fn is_empty(&self) -> bool { ... }
}
Expand description

A trait used to power map-like operations via reflection.

Maps contain zero or more entries of a key and its associated value, and correspond to types like HashMap. The order of these entries is not guaranteed by this trait.

Hashing

All keys are expected to return a valid hash value from Reflect::reflect_hash. If using the #[derive(Reflect)] macro, this can be done by adding #[reflect(Hash)] to the entire struct or enum. This is true even for manual implementors who do not use the hashed value, as it is still relied on by DynamicMap.

Example

use bevy_reflect::{Reflect, Map};
use bevy_utils::HashMap;


let foo: &mut dyn Map = &mut HashMap::<u32, bool>::new();
foo.insert_boxed(Box::new(123_u32), Box::new(true));
assert_eq!(foo.len(), 1);

let field: &dyn Reflect = foo.get(&123_u32).unwrap();
assert_eq!(field.downcast_ref::<bool>(), Some(&true));

Required Methods§

source

fn get(&self, key: &(dyn Reflect + 'static)) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value associated with the given key.

If no value is associated with key, returns None.

source

fn get_mut( &mut self, key: &(dyn Reflect + 'static) ) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value associated with the given key.

If no value is associated with key, returns None.

source

fn get_at( &self, index: usize ) -> Option<(&(dyn Reflect + 'static), &(dyn Reflect + 'static))>

Returns the key-value pair at index by reference, or None if out of bounds.

source

fn get_at_mut( &mut self, index: usize ) -> Option<(&(dyn Reflect + 'static), &mut (dyn Reflect + 'static))>

Returns the key-value pair at index by reference where the value is a mutable reference, or None if out of bounds.

source

fn len(&self) -> usize

Returns the number of elements in the map.

source

fn iter(&self) -> MapIter<'_>

Returns an iterator over the key-value pairs of the map.

source

fn drain(self: Box<Self>) -> Vec<(Box<dyn Reflect>, Box<dyn Reflect>)>

Drain the key-value pairs of this map to get a vector of owned values.

source

fn clone_dynamic(&self) -> DynamicMap

Clones the map, producing a DynamicMap.

source

fn insert_boxed( &mut self, key: Box<dyn Reflect>, value: Box<dyn Reflect> ) -> Option<Box<dyn Reflect>>

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned. If the map did have this key present, the value is updated, and the old value is returned.

source

fn remove(&mut self, key: &(dyn Reflect + 'static)) -> Option<Box<dyn Reflect>>

Removes an entry from the map.

If the map did not have this key present, None is returned. If the map did have this key present, the removed value is returned.

Provided Methods§

source

fn is_empty(&self) -> bool

Returns true if the list contains no elements.

Implementations on Foreign Types§

source§

impl<K, V, S> Map for HashMap<K, V, S>

source§

fn get(&self, key: &(dyn Reflect + 'static)) -> Option<&(dyn Reflect + 'static)>

source§

fn get_mut( &mut self, key: &(dyn Reflect + 'static) ) -> Option<&mut (dyn Reflect + 'static)>

source§

fn get_at( &self, index: usize ) -> Option<(&(dyn Reflect + 'static), &(dyn Reflect + 'static))>

source§

fn get_at_mut( &mut self, index: usize ) -> Option<(&(dyn Reflect + 'static), &mut (dyn Reflect + 'static))>

source§

fn len(&self) -> usize

source§

fn iter(&self) -> MapIter<'_>

source§

fn drain( self: Box<HashMap<K, V, S>> ) -> Vec<(Box<dyn Reflect>, Box<dyn Reflect>)>

source§

fn clone_dynamic(&self) -> DynamicMap

source§

fn insert_boxed( &mut self, key: Box<dyn Reflect>, value: Box<dyn Reflect> ) -> Option<Box<dyn Reflect>>

source§

fn remove(&mut self, key: &(dyn Reflect + 'static)) -> Option<Box<dyn Reflect>>

Implementors§

source§

impl Map for DynamicMap

source§

impl<K, V, S> Map for bevy_internal::utils::hashbrown::HashMap<K, V, S>