Trait bevy::reflect::List

source ·

pub trait List: Reflect {
    // Required methods
    fn get(&self, index: usize) -> Option<&(dyn Reflect + 'static)>;
    fn get_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>;
    fn insert(&mut self, index: usize, element: Box<dyn Reflect>);
    fn remove(&mut self, index: usize) -> Box<dyn Reflect>;
    fn len(&self) -> usize;
    fn iter(&self) -> ListIter<'_> ⓘ;
    fn drain(self: Box<Self>) -> Vec<Box<dyn Reflect>>;

    // Provided methods
    fn push(&mut self, value: Box<dyn Reflect>) { ... }
    fn pop(&mut self) -> Option<Box<dyn Reflect>> { ... }
    fn is_empty(&self) -> bool { ... }
    fn clone_dynamic(&self) -> DynamicList { ... }
}

Expand description

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

This corresponds to types, like Vec, which contain an ordered sequence of elements that implement Reflect.

Unlike the Array trait, implementors of this trait are not expected to maintain a constant length. Methods like insertion and removal explicitly allow for their internal size to change.

push and pop have default implementations, however it will generally be more performant to implement them manually as the default implementation uses a very naive approach to find the correct position.

This trait expects its elements to be ordered linearly from front to back. The front element starts at index 0 with the back element ending at the largest index. This contract above should be upheld by any manual implementors.

Due to the type-erasing nature of the reflection API as a whole, this trait does not make any guarantees that the implementor’s elements are homogeneous (i.e. all the same type).

Example

use bevy_reflect::{Reflect, List};

let foo: &mut dyn List = &mut vec![123_u32, 456_u32, 789_u32];
assert_eq!(foo.len(), 3);

let last_field: Box<dyn Reflect> = foo.pop().unwrap();
assert_eq!(last_field.downcast_ref::<u32>(), Some(&789));