Trait bevy::reflect::Array

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

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

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

Returns a reference to the element at index, or None if out of bounds.

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

Returns a mutable reference to the element at index, or None if out of bounds.

fn len(&self) -> usize

Returns the number of elements in the array.

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

Returns an iterator over the array.

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

Drain the elements of this array to get a vector of owned values.

Provided Methods

fn is_empty(&self) -> bool

Returns true if the collection contains no elements.

fn clone_dynamic(&self) -> DynamicArray

Clones the list, producing a DynamicArray.

Implementations on Foreign Types

impl<T, const N: usize> Array for [T; N]

where T: Reflect + TypePath + GetTypeRegistration,

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<[T; N]>) -> Vec<Box<dyn Reflect>>

Implementors

impl Array for DynamicArray