Trait bevy_internal::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));
Required Methods§
sourcefn get(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
fn get(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
Returns a reference to the element at index
, or None
if out of bounds.
Provided Methods§
sourcefn clone_dynamic(&self) -> DynamicArray
fn clone_dynamic(&self) -> DynamicArray
Clones the list, producing a DynamicArray
.