Add DeserializeReflect trait

Also added the ReflectDeserializeReflect type data

Author: MrGVSV

crates/bevy_reflect/src/serde/de.rs

@@ -1,3 +1,4 @@
+use crate::serde::deserialize_reflect::ReflectDeserializeReflect;
 use crate::serde::SerializationData;
 use crate::{
     ArrayInfo, DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
@@ -355,12 +356,33 @@ pub struct TypedReflectDeserializer<'a> {
 }
 
 impl<'a> TypedReflectDeserializer<'a> {
+    // Creates a new [`TypedReflectDeserializer`] for the given type registration.
     pub fn new(registration: &'a TypeRegistration, registry: &'a TypeRegistry) -> Self {
         Self {
             registration,
             registry,
         }
     }
+
+    /// Creates a new [`TypedReflectDeserializer`] for the given type `T`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `T` is not registered in the given [`TypeRegistry`].
+    pub fn of<T: Reflect>(registry: &'a TypeRegistry) -> Self {
+        let registration = registry
+            .get(std::any::TypeId::of::<T>())
+            .unwrap_or_else(|| {
+                panic!(
+                    "no registration found for type `{}`",
+                    std::any::type_name::<T>()
+                )
+            });
+        Self {
+            registration,
+            registry,
+        }
+    }
 }
 
 impl<'a, 'de> DeserializeSeed<'de> for TypedReflectDeserializer<'a> {
@@ -378,6 +400,11 @@ impl<'a, 'de> DeserializeSeed<'de> for TypedReflectDeserializer<'a> {
             return Ok(value);
         }
 
+        if let Some(deserialize_reflect) = self.registration.data::<ReflectDeserializeReflect>() {
+            let value = deserialize_reflect.deserialize(deserializer, self.registry)?;
+            return Ok(value);
+        }
+
         match self.registration.type_info() {
             TypeInfo::Struct(struct_info) => {
                 let mut dynamic_struct = deserializer.deserialize_struct(

crates/bevy_reflect/src/serde/deserialize_reflect.rs

@@ -0,0 +1,83 @@
+use crate::{FromType, Reflect, TypeRegistry};
+use serde::{Deserialize, Deserializer};
+
+/// Trait used to provide finer control when deserializing a reflected type with one of
+/// the reflection deserializers.
+///
+/// This trait is the reflection equivalent of `serde`'s [`Deserialize`] trait.
+/// The main difference is that this trait provides access to the [`TypeRegistry`],
+/// which means that we can use the registry and all its stored type information
+/// to deserialize our type.
+///
+/// This can be useful when writing a custom reflection deserializer where we may
+/// want to handle parts of the deserialization process, but temporarily pass control
+/// to the standard reflection deserializer for other parts.
+///
+/// Without this trait and its associated [type data], such a deserializer would have to
+/// write out all of the deserialization logic itself, possibly including
+/// unnecessary code duplication and trivial implementations.
+///
+/// # Implementors
+///
+/// In order for this to work with the reflection deserializers like [`TypedReflectDeserializer`]
+/// and [`UntypedReflectDeserializer`], implementors should be sure to register the
+/// [`ReflectDeserializeReflect`] type data.
+/// This can be done [via the registry] or by adding `#[reflect(DeserializeReflect)]` to
+/// the type definition.
+///
+/// Note that this trait has a blanket implementation for all types that implement
+/// [`Reflect`] and [`Deserialize`].
+///
+/// [type data]: ReflectDeserializeReflect
+/// [`TypedReflectDeserializer`]: crate::serde::TypedReflectDeserializer
+/// [`UntypedReflectDeserializer`]: crate::serde::UntypedReflectDeserializer
+/// [via the registry]: TypeRegistry::register_type_data
+pub trait DeserializeReflect<'de>: Reflect + Sized {
+    fn deserialize<D>(deserializer: D, registry: &TypeRegistry) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>;
+}
+
+impl<'de, T: Reflect + Deserialize<'de>> DeserializeReflect<'de> for T {
+    fn deserialize<D>(deserializer: D, _registry: &TypeRegistry) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        <T as Deserialize>::deserialize(deserializer)
+    }
+}
+
+/// Type data used to deserialize a [`Reflect`] type with a custom [`DeserializeReflect`] implementation.
+#[derive(Clone)]
+pub struct ReflectDeserializeReflect {
+    deserialize: fn(
+        deserializer: &mut dyn erased_serde::Deserializer,
+        registry: &TypeRegistry,
+    ) -> Result<Box<dyn Reflect>, erased_serde::Error>,
+}
+
+impl ReflectDeserializeReflect {
+    /// Deserialize a [`Reflect`] type with this type data's custom [`DeserializeReflect`] implementation.
+    pub fn deserialize<'de, D>(
+        &self,
+        deserializer: D,
+        registry: &TypeRegistry,
+    ) -> Result<Box<dyn Reflect>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let mut erased = <dyn erased_serde::Deserializer>::erase(deserializer);
+        (self.deserialize)(&mut erased, registry)
+            .map_err(<<D as Deserializer<'de>>::Error as serde::de::Error>::custom)
+    }
+}
+
+impl<T: Reflect + for<'de> DeserializeReflect<'de>> FromType<T> for ReflectDeserializeReflect {
+    fn from_type() -> Self {
+        Self {
+            deserialize: |deserializer, registry| {
+                Ok(Box::new(T::deserialize(deserializer, registry)?))
+            },
+        }
+    }
+}

crates/bevy_reflect/src/serde/mod.rs

@@ -1,20 +1,28 @@
 mod de;
+mod deserialize_reflect;
 mod ser;
 mod type_data;
 
 pub use de::*;
+pub use deserialize_reflect::*;
 pub use ser::*;
 pub use type_data::*;
 
 #[cfg(test)]
 mod tests {
-    use crate::{self as bevy_reflect, DynamicTupleStruct};
+    use crate::{self as bevy_reflect, DynamicTupleStruct, ReflectDeserialize, Struct};
     use crate::{
-        serde::{ReflectSerializer, UntypedReflectDeserializer},
+        serde::{
+            DeserializeReflect, ReflectDeserializeReflect, ReflectSerializer,
+            TypedReflectDeserializer, UntypedReflectDeserializer,
+        },
         type_registry::TypeRegistry,
         DynamicStruct, Reflect,
     };
-    use serde::de::DeserializeSeed;
+    use bevy_reflect_derive::FromReflect;
+    use serde::de::{DeserializeSeed, SeqAccess, Visitor};
+    use serde::{Deserialize, Deserializer};
+    use std::fmt::Formatter;
 
     #[test]
     fn test_serialization_struct() {
@@ -104,4 +112,138 @@ mod tests {
         let serializer = ReflectSerializer::new(&value, &registry);
         ron::ser::to_string(&serializer).unwrap();
     }
+
+    #[test]
+    fn should_deserialize_using_deserialize_reflect() {
+        #[derive(Reflect, FromReflect, PartialEq, Debug, Deserialize)]
+        #[reflect(Deserialize)]
+        enum AnimalType {
+            Dog,
+            Cat,
+        }
+
+        #[derive(Reflect, FromReflect)]
+        struct Dog {
+            name: DogName,
+        }
+
+        #[derive(Reflect, FromReflect)]
+        enum DogName {
+            Spot,
+            Fido,
+            Rex,
+        }
+
+        #[derive(Reflect, FromReflect)]
+        struct Cat {
+            name: CatName,
+        }
+
+        #[derive(Reflect, FromReflect)]
+        enum CatName {
+            Fluffy,
+            Snowball,
+            Luna,
+        }
+
+        /// Pet is made up of two fields: the type of animal and the animal itself.
+        ///
+        /// This allows us to store a type-erased version of our pet,
+        /// rather than having to define one like this:
+        ///
+        /// ```
+        /// # use bevy_reflect::prelude::Reflect;
+        /// #[derive(Reflect)]
+        /// struct Pet<T: Reflect>(T);
+        /// ```
+        ///
+        /// If we wanted to allow for deserialization of any type,
+        /// we could replace `AnimalType` with a `String` containing the type name of the animal.
+        #[derive(Reflect)]
+        #[reflect(DeserializeReflect)]
+        struct Pet(AnimalType, DynamicStruct);
+
+        impl<'de> DeserializeReflect<'de> for Pet {
+            fn deserialize<D>(deserializer: D, registry: &TypeRegistry) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct PetVisitor<'a> {
+                    registry: &'a TypeRegistry,
+                }
+                impl<'a, 'de> Visitor<'de> for PetVisitor<'a> {
+                    type Value = Pet;
+
+                    fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+                        write!(formatter, "a pet tuple struct")
+                    }
+
+                    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+                    where
+                        A: SeqAccess<'de>,
+                    {
+                        let kind = seq.next_element::<AnimalType>()?.unwrap();
+                        match kind {
+                            AnimalType::Cat => {
+                                let cat = seq
+                                    .next_element_seed(TypedReflectDeserializer::of::<Cat>(
+                                        self.registry,
+                                    ))?
+                                    .unwrap()
+                                    .take::<DynamicStruct>()
+                                    .unwrap();
+                                Ok(Pet(kind, cat))
+                            }
+                            AnimalType::Dog => {
+                                let dog = seq
+                                    .next_element_seed(TypedReflectDeserializer::of::<Dog>(
+                                        self.registry,
+                                    ))?
+                                    .unwrap()
+                                    .take::<DynamicStruct>()
+                                    .unwrap();
+                                Ok(Pet(kind, dog))
+                            }
+                        }
+                    }
+                }
+
+                deserializer.deserialize_tuple_struct("Pet", 1, PetVisitor { registry })
+            }
+        }
+
+        let mut registry = TypeRegistry::default();
+        registry.register::<Pet>();
+        registry.register::<AnimalType>();
+        registry.register::<Dog>();
+        registry.register::<DogName>();
+        registry.register::<Cat>();
+        registry.register::<CatName>();
+
+        let pet = Pet(
+            AnimalType::Cat,
+            Cat {
+                name: CatName::Fluffy,
+            }
+            .clone_dynamic(),
+        );
+
+        let serializer = ReflectSerializer::new(&pet, &registry);
+        let serialized = ron::ser::to_string(&serializer).unwrap();
+
+        let expected = r#"{"bevy_reflect::serde::tests::should_deserialize_using_deserialize_reflect::Pet":(Cat,(name:Fluffy))}"#;
+
+        assert_eq!(expected, serialized);
+
+        let mut deserializer = ron::de::Deserializer::from_str(&serialized).unwrap();
+        let reflect_deserializer = UntypedReflectDeserializer::new(&registry);
+        let value = reflect_deserializer.deserialize(&mut deserializer).unwrap();
+        let deserialized = value.take::<Pet>().unwrap();
+
+        assert_eq!(pet.0, deserialized.0);
+        assert!(pet
+            .1
+            .reflect_partial_eq(&deserialized.1)
+            .unwrap_or_default());
+    }
 }