Trait bevy::reflect::Map

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 { ... }
}

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

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.

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.

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.

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.

fn len(&self) -> usize

Returns the number of elements in the map.

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

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

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.

fn clone_dynamic(&self) -> DynamicMap

Clones the map, producing a DynamicMap.

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.

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

fn is_empty(&self) -> bool

Returns true if the list contains no elements.

Implementations on Foreign Types

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

where K: FromReflect + TypePath + Eq + Hash, V: FromReflect + TypePath, S: TypePath + BuildHasher + Send + Sync,

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<HashMap<K, V, S>> ) -> 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>>

Implementors

impl Map for DynamicMap

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

where K: FromReflect + TypePath + Eq + Hash, V: FromReflect + TypePath, S: TypePath + BuildHasher + Send + Sync,