Trait bevy::reflect::Array

source ·

pub trait Array: 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 len(&self) -> usize;
    fn iter(&self) -> ArrayIter<'_> ⓘ;
    fn drain(self: Box<Self>) -> Vec<Box<dyn Reflect>>;

    // Provided methods
    fn is_empty(&self) -> bool { ... }
    fn clone_dynamic(&self) -> DynamicArray { ... }
}

Expand description

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

This corresponds to true Rust arrays like [T; N], but also to any fixed-size linear sequence types. It is expected that implementors of this trait uphold this contract and maintain a fixed size as returned by the Array::len method.

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).

This trait has a blanket implementation over Rust arrays of up to 32 items. This implementation can technically contain more than 32, but the blanket GetTypeRegistration is only implemented up to the 32 item limit due to a limitation on Deserialize.

Example

use bevy_reflect::{Reflect, Array};

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

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