|
| 1 | +use crate::{FromType, Reflect}; |
| 2 | + |
| 3 | +/// A trait for types which can be constructed from a reflected type. |
| 4 | +/// |
| 5 | +/// This trait can be derived on types which implement [`Reflect`]. Some complex |
| 6 | +/// types (such as `Vec<T>`) may only be reflected if their element types |
| 7 | +/// implement this trait. |
| 8 | +/// |
| 9 | +/// For structs and tuple structs, fields marked with the `#[reflect(ignore)]` |
| 10 | +/// attribute will be constructed using the `Default` implementation of the |
| 11 | +/// field type, rather than the corresponding field value (if any) of the |
| 12 | +/// reflected value. |
| 13 | +pub trait FromReflect: Reflect + Sized { |
| 14 | + /// Constructs a concrete instance of `Self` from a reflected value. |
| 15 | + fn from_reflect(reflect: &dyn Reflect) -> Option<Self>; |
| 16 | +} |
| 17 | + |
| 18 | +/// Type data that represents the [`FromReflect`] trait and allows it to be used dynamically. |
| 19 | +/// |
| 20 | +/// `FromReflect` allows dynamic types (e.g. [`DynamicStruct`], [`DynamicEnum`], etc.) to be converted |
| 21 | +/// to their full, concrete types. This is most important when it comes to deserialization where it isn't |
| 22 | +/// guaranteed that every field exists when trying to construct the final output. |
| 23 | +/// |
| 24 | +/// However, to do this, you normally need to specify the exact concrete type: |
| 25 | +/// |
| 26 | +/// ``` |
| 27 | +/// # use bevy_reflect::{DynamicTupleStruct, FromReflect, Reflect}; |
| 28 | +/// #[derive(Reflect, PartialEq, Eq, Debug)] |
| 29 | +/// struct Foo(#[reflect(default = "default_value")] usize); |
| 30 | +/// |
| 31 | +/// fn default_value() -> usize { 123 } |
| 32 | +/// |
| 33 | +/// let reflected = DynamicTupleStruct::default(); |
| 34 | +/// |
| 35 | +/// let concrete: Foo = <Foo as FromReflect>::from_reflect(&reflected).unwrap(); |
| 36 | +/// |
| 37 | +/// assert_eq!(Foo(123), concrete); |
| 38 | +/// ``` |
| 39 | +/// |
| 40 | +/// In a dynamic context where the type might not be known at compile-time, this is nearly impossible to do. |
| 41 | +/// That is why this type data struct exists— it allows us to construct the full type without knowing |
| 42 | +/// what the actual type is. |
| 43 | +/// |
| 44 | +/// # Example |
| 45 | +/// |
| 46 | +/// ``` |
| 47 | +/// # use bevy_reflect::{DynamicTupleStruct, FromReflect, Reflect, ReflectFromReflect, TypeRegistry}; |
| 48 | +/// # #[derive(Reflect, PartialEq, Eq, Debug)] |
| 49 | +/// # struct Foo(#[reflect(default = "default_value")] usize); |
| 50 | +/// # fn default_value() -> usize { 123 } |
| 51 | +/// # let mut registry = TypeRegistry::new(); |
| 52 | +/// # registry.register::<Foo>(); |
| 53 | +/// |
| 54 | +/// let mut reflected = DynamicTupleStruct::default(); |
| 55 | +/// reflected.set_name(std::any::type_name::<Foo>().to_string()); |
| 56 | +/// |
| 57 | +/// let registration = registry.get_with_name(reflected.type_name()).unwrap(); |
| 58 | +/// let rfr = registration.data::<ReflectFromReflect>().unwrap(); |
| 59 | +/// |
| 60 | +/// let concrete: Box<dyn Reflect> = rfr.from_reflect(&reflected).unwrap(); |
| 61 | +/// |
| 62 | +/// assert_eq!(Foo(123), concrete.take::<Foo>().unwrap()); |
| 63 | +/// ``` |
| 64 | +/// |
| 65 | +/// [`DynamicStruct`]: crate::DynamicStruct |
| 66 | +/// [`DynamicEnum`]: crate::DynamicEnum |
| 67 | +#[derive(Clone)] |
| 68 | +pub struct ReflectFromReflect { |
| 69 | + from_reflect: fn(&dyn Reflect) -> Option<Box<dyn Reflect>>, |
| 70 | +} |
| 71 | + |
| 72 | +impl ReflectFromReflect { |
| 73 | + /// Perform a [`FromReflect::from_reflect`] conversion on the given reflection object. |
| 74 | + /// |
| 75 | + /// This will convert the object to a concrete type if it wasn't already, and return |
| 76 | + /// the value as `Box<dyn Reflect>`. |
| 77 | + #[allow(clippy::wrong_self_convention)] |
| 78 | + pub fn from_reflect(&self, reflect_value: &dyn Reflect) -> Option<Box<dyn Reflect>> { |
| 79 | + (self.from_reflect)(reflect_value) |
| 80 | + } |
| 81 | +} |
| 82 | + |
| 83 | +impl<T: FromReflect + Reflect> FromType<T> for ReflectFromReflect { |
| 84 | + fn from_type() -> Self { |
| 85 | + Self { |
| 86 | + from_reflect: |reflect_value| { |
| 87 | + T::from_reflect(reflect_value).map(|value| Box::new(value) as Box<dyn Reflect>) |
| 88 | + }, |
| 89 | + } |
| 90 | + } |
| 91 | +} |
0 commit comments