Added ReflectFromReflect

Author: MrGVSV

crates/bevy_reflect/src/from_reflect.rs

@@ -0,0 +1,93 @@
+use crate::{FromType, Reflect};
+
+/// A trait for types which can be constructed from a reflected type.
+///
+/// This trait can be derived on types which implement [`Reflect`]. Some complex
+/// types (such as `Vec<T>`) may only be reflected if their element types
+/// implement this trait.
+///
+/// For structs and tuple structs, fields marked with the `#[reflect(ignore)]`
+/// attribute will be constructed using the `Default` implementation of the
+/// field type, rather than the corresponding field value (if any) of the
+/// reflected value.
+pub trait FromReflect: Reflect + Sized {
+    /// Constructs a concrete instance of `Self` from a reflected value.
+    fn from_reflect(reflect: &dyn Reflect) -> Option<Self>;
+}
+
+/// 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:
+///
+/// ```
+/// # use bevy_reflect::{DynamicTupleStruct, FromReflect, Reflect};
+/// #[derive(Reflect, FromReflect, PartialEq, Eq, Debug)]
+/// #[reflect(FromReflect)]
+/// 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
+///
+/// ```
+/// # use bevy_reflect::{DynamicTupleStruct, FromReflect, Reflect, ReflectFromReflect, TypeRegistry};
+/// # #[derive(Reflect, FromReflect, PartialEq, Eq, Debug)]
+/// # #[reflect(FromReflect)]
+/// # struct Foo(#[reflect(default = "default_value")] usize);
+/// # fn default_value() -> usize { 123 }
+/// # let mut registry = TypeRegistry::new();
+/// # registry.register::<Foo>();
+///
+/// let mut reflected = DynamicTupleStruct::default();
+/// reflected.set_name(std::any::type_name::<Foo>().to_string());
+///
+/// let registration = registry.get_with_name(reflected.type_name()).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());
+/// ```
+///
+/// [`DynamicStruct`]: crate::DynamicStruct
+/// [`DynamicEnum`]: crate::DynamicEnum
+#[derive(Clone)]
+pub struct ReflectFromReflect {
+    from_reflect: fn(&dyn Reflect) -> Option<Box<dyn Reflect>>,
+}
+
+impl ReflectFromReflect {
+    /// 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>`.
+    #[allow(clippy::wrong_self_convention)]
+    pub fn from_reflect(&self, reflect_value: &dyn Reflect) -> Option<Box<dyn Reflect>> {
+        (self.from_reflect)(reflect_value)
+    }
+}
+
+impl<T: FromReflect + Reflect> FromType<T> for ReflectFromReflect {
+    fn from_type() -> Self {
+        Self {
+            from_reflect: |reflect_value| {
+                T::from_reflect(reflect_value).map(|value| Box::new(value) as Box<dyn Reflect>)
+            },
+        }
+    }
+}

crates/bevy_reflect/src/lib.rs

@@ -2,6 +2,7 @@
 
 mod array;
 mod fields;
+mod from_reflect;
 mod list;
 mod map;
 mod path;
@@ -47,6 +48,7 @@ pub mod prelude {
 pub use array::*;
 pub use enums::*;
 pub use fields::*;
+pub use from_reflect::*;
 pub use impls::*;
 pub use list::*;
 pub use map::*;
@@ -103,6 +105,7 @@ mod tests {
         ser::{to_string_pretty, PrettyConfig},
         Deserializer,
     };
+    use std::any::TypeId;
     use std::fmt::{Debug, Formatter};
 
     use super::prelude::*;
@@ -244,6 +247,42 @@ mod tests {
         assert_eq!(values, vec![1]);
     }
 
+    #[test]
+    fn should_call_from_reflect_dynamically() {
+        #[derive(Reflect, FromReflect)]
+        #[reflect(FromReflect)]
+        struct MyStruct {
+            foo: usize,
+        }
+
+        // Register
+        let mut registry = TypeRegistry::default();
+        registry.register::<MyStruct>();
+
+        // Get type data
+        let type_id = TypeId::of::<MyStruct>();
+        let rfr = registry
+            .get_type_data::<ReflectFromReflect>(type_id)
+            .expect("the FromReflect trait should be registered");
+
+        // Call from_reflect
+        let mut dynamic_struct = DynamicStruct::default();
+        dynamic_struct.insert("foo", 123usize);
+        let reflected = rfr
+            .from_reflect(&dynamic_struct)
+            .expect("the type should be properly reflected");
+
+        // Assert
+        let expected = MyStruct { foo: 123 };
+        assert!(expected
+            .reflect_partial_eq(reflected.as_ref())
+            .unwrap_or_default());
+        let not_expected = MyStruct { foo: 321 };
+        assert!(!not_expected
+            .reflect_partial_eq(reflected.as_ref())
+            .unwrap_or_default());
+    }
+
     #[test]
     fn from_reflect_should_use_default_field_attributes() {
         #[derive(Reflect, FromReflect, Eq, PartialEq, Debug)]

crates/bevy_reflect/src/reflect.rs

@@ -190,21 +190,6 @@ pub trait Reflect: Any + Send + Sync {
     }
 }
 
-/// A trait for types which can be constructed from a reflected type.
-///
-/// This trait can be derived on types which implement [`Reflect`]. Some complex
-/// types (such as `Vec<T>`) may only be reflected if their element types
-/// implement this trait.
-///
-/// For structs and tuple structs, fields marked with the `#[reflect(ignore)]`
-/// attribute will be constructed using the `Default` implementation of the
-/// field type, rather than the corresponding field value (if any) of the
-/// reflected value.
-pub trait FromReflect: Reflect + Sized {
-    /// Constructs a concrete instance of `Self` from a reflected value.
-    fn from_reflect(reflect: &dyn Reflect) -> Option<Self>;
-}
-
 impl Debug for dyn Reflect {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.debug(f)
@@ -255,6 +240,8 @@ impl dyn Reflect {
     /// a different type, like the Dynamic\*\*\* types do, you can call `represents`
     /// to determine what type they represent. Represented types cannot be downcasted
     /// to, but you can use [`FromReflect`] to create a value of the represented type from them.
+    ///
+    /// [`FromReflect`]: crate::FromReflect
     #[inline]
     pub fn is<T: Reflect>(&self) -> bool {
         self.type_id() == TypeId::of::<T>()