Struct bevy_internal::reflect::ReflectFromReflect

pub struct ReflectFromReflect { /* private fields */ }

Type data that represents the FromReflect trait and allows it to be used dynamically.

FromReflect allows dynamic types (e.g. DynamicStruct, DynamicEnum, etc.) to be converted to their full, concrete types. This is most important when it comes to deserialization where it isn’t guaranteed that every field exists when trying to construct the final output.

However, to do this, you normally need to specify the exact concrete type:

#[derive(Reflect, PartialEq, Eq, Debug)]
struct Foo(#[reflect(default = "default_value")] usize);

fn default_value() -> usize { 123 }

let reflected = DynamicTupleStruct::default();

let concrete: Foo = <Foo as FromReflect>::from_reflect(&reflected).unwrap();

assert_eq!(Foo(123), concrete);

In a dynamic context where the type might not be known at compile-time, this is nearly impossible to do. That is why this type data struct exists— it allows us to construct the full type without knowing what the actual type is.

Example

let mut reflected = DynamicTupleStruct::default();
reflected.set_represented_type(Some(<Foo as Typed>::type_info()));

let registration = registry.get_with_type_path(<Foo as TypePath>::type_path()).unwrap();
let rfr = registration.data::<ReflectFromReflect>().unwrap();

let concrete: Box<dyn Reflect> = rfr.from_reflect(&reflected).unwrap();

assert_eq!(Foo(123), concrete.take::<Foo>().unwrap());

Implementations

impl ReflectFromReflect

pub fn from_reflect( &self, reflect_value: &(dyn Reflect + 'static) ) -> Option<Box<dyn Reflect>>

Perform a FromReflect::from_reflect conversion on the given reflection object.

This will convert the object to a concrete type if it wasn’t already, and return the value as Box<dyn Reflect>.

Trait Implementations

impl Clone for ReflectFromReflect

fn clone(&self) -> ReflectFromReflect

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> FromType<T> for ReflectFromReflect

where T: FromReflect,

fn from_type() -> ReflectFromReflect