bevy_reflect: Add ReflectSerializerProcessor

crates/bevy_reflect/src/serde/de/processor.rs

@@ -15,6 +15,8 @@ use crate::{PartialReflect, TypeRegistration, TypeRegistry};
 /// deserializer and give back a [`Box<dyn PartialReflect>`], or return
 /// ownership of the deserializer back, and continue with the default logic.
 ///
+/// The serialization equivalent of this is [`ReflectSerializerProcessor`].
+///
 /// # Compared to [`DeserializeWithRegistry`]
 ///
 /// [`DeserializeWithRegistry`] allows you to define how your type will be
@@ -134,6 +136,7 @@ use crate::{PartialReflect, TypeRegistration, TypeRegistry};
 /// [`TypedReflectDeserializer`]: crate::serde::TypedReflectDeserializer
 /// [`try_deserialize`]: Self::try_deserialize
 /// [`DeserializeWithRegistry`]: crate::serde::DeserializeWithRegistry
+/// [`ReflectSerializerProcessor`]: crate::serde::ReflectSerializerProcessor
 pub trait ReflectDeserializerProcessor {
     /// Attempts to deserialize the value which a [`TypedReflectDeserializer`]
     /// is currently looking at, and knows the type of.

crates/bevy_reflect/src/serde/ser/arrays.rs

@@ -1,26 +1,27 @@
 use crate::{serde::TypedReflectSerializer, Array, TypeRegistry};
 use serde::{ser::SerializeTuple, Serialize};
 
-/// A serializer for [`Array`] values.
-pub(super) struct ArraySerializer<'a> {
-    array: &'a dyn Array,
-    registry: &'a TypeRegistry,
-}
+use super::ReflectSerializerProcessor;
 
-impl<'a> ArraySerializer<'a> {
-    pub fn new(array: &'a dyn Array, registry: &'a TypeRegistry) -> Self {
-        Self { array, registry }
-    }
+/// A serializer for [`Array`] values.
+pub(super) struct ArraySerializer<'a, P> {
+    pub array: &'a dyn Array,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
 }
 
-impl<'a> Serialize for ArraySerializer<'a> {
+impl<P: ReflectSerializerProcessor> Serialize for ArraySerializer<'_, P> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         let mut state = serializer.serialize_tuple(self.array.len())?;
         for value in self.array.iter() {
-            state.serialize_element(&TypedReflectSerializer::new_internal(value, self.registry))?;
+            state.serialize_element(&TypedReflectSerializer::new_internal(
+                value,
+                self.registry,
+                self.processor,
+            ))?;
         }
         state.end()
     }

crates/bevy_reflect/src/serde/ser/enums.rs

@@ -7,22 +7,16 @@ use serde::{
     Serialize,
 };
 
-/// A serializer for [`Enum`] values.
-pub(super) struct EnumSerializer<'a> {
-    enum_value: &'a dyn Enum,
-    registry: &'a TypeRegistry,
-}
+use super::ReflectSerializerProcessor;
 
-impl<'a> EnumSerializer<'a> {
-    pub fn new(enum_value: &'a dyn Enum, registry: &'a TypeRegistry) -> Self {
-        Self {
-            enum_value,
-            registry,
-        }
-    }
+/// A serializer for [`Enum`] values.
+pub(super) struct EnumSerializer<'a, P> {
+    pub enum_value: &'a dyn Enum,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
 }
 
-impl<'a> Serialize for EnumSerializer<'a> {
+impl<P: ReflectSerializerProcessor> Serialize for EnumSerializer<'_, P> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -86,7 +80,11 @@ impl<'a> Serialize for EnumSerializer<'a> {
                     let field_info = struct_info.field_at(index).unwrap();
                     state.serialize_field(
                         field_info.name(),
-                        &TypedReflectSerializer::new_internal(field.value(), self.registry),
+                        &TypedReflectSerializer::new_internal(
+                            field.value(),
+                            self.registry,
+                            self.processor,
+                        ),
                     )?;
                 }
                 state.end()
@@ -97,14 +95,17 @@ impl<'a> Serialize for EnumSerializer<'a> {
                 if type_info.type_path_table().module_path() == Some("core::option")
                     && type_info.type_path_table().ident() == Some("Option")
                 {
-                    serializer
-                        .serialize_some(&TypedReflectSerializer::new_internal(field, self.registry))
+                    serializer.serialize_some(&TypedReflectSerializer::new_internal(
+                        field,
+                        self.registry,
+                        self.processor,
+                    ))
                 } else {
                     serializer.serialize_newtype_variant(
                         enum_name,
                         variant_index,
                         variant_name,
-                        &TypedReflectSerializer::new_internal(field, self.registry),
+                        &TypedReflectSerializer::new_internal(field, self.registry, self.processor),
                     )
                 }
             }
@@ -119,6 +120,7 @@ impl<'a> Serialize for EnumSerializer<'a> {
                     state.serialize_field(&TypedReflectSerializer::new_internal(
                         field.value(),
                         self.registry,
+                        self.processor,
                     ))?;
                 }
                 state.end()

crates/bevy_reflect/src/serde/ser/lists.rs

@@ -1,26 +1,27 @@
 use crate::{serde::TypedReflectSerializer, List, TypeRegistry};
 use serde::{ser::SerializeSeq, Serialize};
 
-/// A serializer for [`List`] values.
-pub(super) struct ListSerializer<'a> {
-    list: &'a dyn List,
-    registry: &'a TypeRegistry,
-}
+use super::ReflectSerializerProcessor;
 
-impl<'a> ListSerializer<'a> {
-    pub fn new(list: &'a dyn List, registry: &'a TypeRegistry) -> Self {
-        Self { list, registry }
-    }
+/// A serializer for [`List`] values.
+pub(super) struct ListSerializer<'a, P> {
+    pub list: &'a dyn List,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
 }
 
-impl<'a> Serialize for ListSerializer<'a> {
+impl<P: ReflectSerializerProcessor> Serialize for ListSerializer<'_, P> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         let mut state = serializer.serialize_seq(Some(self.list.len()))?;
         for value in self.list.iter() {
-            state.serialize_element(&TypedReflectSerializer::new_internal(value, self.registry))?;
+            state.serialize_element(&TypedReflectSerializer::new_internal(
+                value,
+                self.registry,
+                self.processor,
+            ))?;
         }
         state.end()
     }

crates/bevy_reflect/src/serde/ser/maps.rs

@@ -1,28 +1,25 @@
 use crate::{serde::TypedReflectSerializer, Map, TypeRegistry};
 use serde::{ser::SerializeMap, Serialize};
 
-/// A serializer for [`Map`] values.
-pub(super) struct MapSerializer<'a> {
-    map: &'a dyn Map,
-    registry: &'a TypeRegistry,
-}
+use super::ReflectSerializerProcessor;
 
-impl<'a> MapSerializer<'a> {
-    pub fn new(map: &'a dyn Map, registry: &'a TypeRegistry) -> Self {
-        Self { map, registry }
-    }
+/// A serializer for [`Map`] values.
+pub(super) struct MapSerializer<'a, P> {
+    pub map: &'a dyn Map,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
 }
 
-impl<'a> Serialize for MapSerializer<'a> {
+impl<P: ReflectSerializerProcessor> Serialize for MapSerializer<'_, P> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         let mut state = serializer.serialize_map(Some(self.map.len()))?;
         for (key, value) in self.map.iter() {
             state.serialize_entry(
-                &TypedReflectSerializer::new_internal(key, self.registry),
-                &TypedReflectSerializer::new_internal(value, self.registry),
+                &TypedReflectSerializer::new_internal(key, self.registry, self.processor),
+                &TypedReflectSerializer::new_internal(value, self.registry, self.processor),
             )?;
         }
         state.end()