bevy_reflect/serde/
de.rs

1use crate::serde::SerializationData;
2use crate::{
3    ArrayInfo, DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
4    DynamicTupleStruct, DynamicVariant, EnumInfo, ListInfo, Map, MapInfo, NamedField, Reflect,
5    ReflectDeserialize, StructInfo, StructVariantInfo, TupleInfo, TupleStructInfo,
6    TupleVariantInfo, TypeInfo, TypeRegistration, TypeRegistry, VariantInfo,
7};
8use erased_serde::Deserializer;
9use serde::de::{
10    DeserializeSeed, EnumAccess, Error, IgnoredAny, MapAccess, SeqAccess, VariantAccess, Visitor,
11};
12use serde::Deserialize;
13use std::any::TypeId;
14use std::fmt;
15use std::fmt::{Debug, Display, Formatter};
16use std::slice::Iter;
17
18pub trait DeserializeValue {
19    fn deserialize(
20        deserializer: &mut dyn Deserializer,
21        type_registry: &TypeRegistry,
22    ) -> Result<Box<dyn Reflect>, erased_serde::Error>;
23}
24
25trait StructLikeInfo {
26    fn get_field(&self, name: &str) -> Option<&NamedField>;
27    fn field_at(&self, index: usize) -> Option<&NamedField>;
28    fn get_field_len(&self) -> usize;
29    fn iter_fields(&self) -> Iter<'_, NamedField>;
30}
31
32trait TupleLikeInfo {
33    fn get_field_len(&self) -> usize;
34}
35
36trait Container {
37    fn get_field_registration<'a, E: Error>(
38        &self,
39        index: usize,
40        registry: &'a TypeRegistry,
41    ) -> Result<&'a TypeRegistration, E>;
42}
43
44impl StructLikeInfo for StructInfo {
45    fn get_field(&self, name: &str) -> Option<&NamedField> {
46        self.field(name)
47    }
48
49    fn field_at(&self, index: usize) -> Option<&NamedField> {
50        self.field_at(index)
51    }
52
53    fn get_field_len(&self) -> usize {
54        self.field_len()
55    }
56
57    fn iter_fields(&self) -> Iter<'_, NamedField> {
58        self.iter()
59    }
60}
61
62impl Container for StructInfo {
63    fn get_field_registration<'a, E: Error>(
64        &self,
65        index: usize,
66        registry: &'a TypeRegistry,
67    ) -> Result<&'a TypeRegistration, E> {
68        let field = self.field_at(index).ok_or_else(|| {
69            Error::custom(format_args!(
70                "no field at index {} on struct {}",
71                index,
72                self.type_path(),
73            ))
74        })?;
75        get_registration(field.type_id(), field.type_path(), registry)
76    }
77}
78
79impl StructLikeInfo for StructVariantInfo {
80    fn get_field(&self, name: &str) -> Option<&NamedField> {
81        self.field(name)
82    }
83
84    fn field_at(&self, index: usize) -> Option<&NamedField> {
85        self.field_at(index)
86    }
87
88    fn get_field_len(&self) -> usize {
89        self.field_len()
90    }
91
92    fn iter_fields(&self) -> Iter<'_, NamedField> {
93        self.iter()
94    }
95}
96
97impl Container for StructVariantInfo {
98    fn get_field_registration<'a, E: Error>(
99        &self,
100        index: usize,
101        registry: &'a TypeRegistry,
102    ) -> Result<&'a TypeRegistration, E> {
103        let field = self.field_at(index).ok_or_else(|| {
104            Error::custom(format_args!(
105                "no field at index {} on variant {}",
106                index,
107                self.name(),
108            ))
109        })?;
110        get_registration(field.type_id(), field.type_path(), registry)
111    }
112}
113
114impl TupleLikeInfo for TupleInfo {
115    fn get_field_len(&self) -> usize {
116        self.field_len()
117    }
118}
119
120impl Container for TupleInfo {
121    fn get_field_registration<'a, E: Error>(
122        &self,
123        index: usize,
124        registry: &'a TypeRegistry,
125    ) -> Result<&'a TypeRegistration, E> {
126        let field = self.field_at(index).ok_or_else(|| {
127            Error::custom(format_args!(
128                "no field at index {} on tuple {}",
129                index,
130                self.type_path(),
131            ))
132        })?;
133        get_registration(field.type_id(), field.type_path(), registry)
134    }
135}
136
137impl TupleLikeInfo for TupleStructInfo {
138    fn get_field_len(&self) -> usize {
139        self.field_len()
140    }
141}
142
143impl Container for TupleStructInfo {
144    fn get_field_registration<'a, E: Error>(
145        &self,
146        index: usize,
147        registry: &'a TypeRegistry,
148    ) -> Result<&'a TypeRegistration, E> {
149        let field = self.field_at(index).ok_or_else(|| {
150            Error::custom(format_args!(
151                "no field at index {} on tuple struct {}",
152                index,
153                self.type_path(),
154            ))
155        })?;
156        get_registration(field.type_id(), field.type_path(), registry)
157    }
158}
159
160impl TupleLikeInfo for TupleVariantInfo {
161    fn get_field_len(&self) -> usize {
162        self.field_len()
163    }
164}
165
166impl Container for TupleVariantInfo {
167    fn get_field_registration<'a, E: Error>(
168        &self,
169        index: usize,
170        registry: &'a TypeRegistry,
171    ) -> Result<&'a TypeRegistration, E> {
172        let field = self.field_at(index).ok_or_else(|| {
173            Error::custom(format_args!(
174                "no field at index {} on tuple variant {}",
175                index,
176                self.name(),
177            ))
178        })?;
179        get_registration(field.type_id(), field.type_path(), registry)
180    }
181}
182
183/// A debug struct used for error messages that displays a list of expected values.
184///
185/// # Example
186///
187/// ```ignore (Can't import private struct from doctest)
188/// let expected = vec!["foo", "bar", "baz"];
189/// assert_eq!("`foo`, `bar`, `baz`", format!("{}", ExpectedValues(expected)));
190/// ```
191struct ExpectedValues<T: Display>(Vec<T>);
192
193impl<T: Display> Debug for ExpectedValues<T> {
194    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
195        let len = self.0.len();
196        for (index, item) in self.0.iter().enumerate() {
197            write!(f, "`{item}`")?;
198            if index < len - 1 {
199                write!(f, ", ")?;
200            }
201        }
202        Ok(())
203    }
204}
205
206/// Represents a simple reflected identifier.
207#[derive(Debug, Clone, Eq, PartialEq)]
208struct Ident(String);
209
210impl<'de> Deserialize<'de> for Ident {
211    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
212    where
213        D: serde::Deserializer<'de>,
214    {
215        struct IdentVisitor;
216
217        impl<'de> Visitor<'de> for IdentVisitor {
218            type Value = Ident;
219
220            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
221                formatter.write_str("identifier")
222            }
223
224            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
225            where
226                E: Error,
227            {
228                Ok(Ident(value.to_string()))
229            }
230
231            fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
232            where
233                E: Error,
234            {
235                Ok(Ident(value))
236            }
237        }
238
239        deserializer.deserialize_identifier(IdentVisitor)
240    }
241}
242
243/// A deserializer for type registrations.
244///
245/// This will return a [`&TypeRegistration`] corresponding to the given type.
246/// This deserializer expects a string containing the _full_ [type path] of the
247/// type to find the `TypeRegistration` of.
248///
249/// [`&TypeRegistration`]: TypeRegistration
250/// [type path]: crate::TypePath::type_path
251pub struct TypeRegistrationDeserializer<'a> {
252    registry: &'a TypeRegistry,
253}
254
255impl<'a> TypeRegistrationDeserializer<'a> {
256    pub fn new(registry: &'a TypeRegistry) -> Self {
257        Self { registry }
258    }
259}
260
261impl<'a, 'de> DeserializeSeed<'de> for TypeRegistrationDeserializer<'a> {
262    type Value = &'a TypeRegistration;
263
264    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
265    where
266        D: serde::Deserializer<'de>,
267    {
268        struct TypeRegistrationVisitor<'a>(&'a TypeRegistry);
269
270        impl<'de, 'a> Visitor<'de> for TypeRegistrationVisitor<'a> {
271            type Value = &'a TypeRegistration;
272
273            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
274                formatter.write_str("string containing `type` entry for the reflected value")
275            }
276
277            fn visit_str<E>(self, type_path: &str) -> Result<Self::Value, E>
278            where
279                E: Error,
280            {
281                self.0.get_with_type_path(type_path).ok_or_else(|| {
282                    Error::custom(format_args!("No registration found for `{type_path}`"))
283                })
284            }
285        }
286
287        deserializer.deserialize_str(TypeRegistrationVisitor(self.registry))
288    }
289}
290
291/// A general purpose deserializer for reflected types.
292///
293/// This is the deserializer counterpart to [`ReflectSerializer`].
294///
295/// See [`TypedReflectDeserializer`] for a deserializer that expects a known type.
296///
297/// # Input
298///
299/// This deserializer expects a map with a single entry,
300/// where the key is the _full_ [type path] of the reflected type
301/// and the value is the serialized data.
302///
303/// # Output
304///
305/// This deserializer will return a [`Box<dyn Reflect>`] containing the deserialized data.
306///
307/// For value types (i.e. [`ReflectKind::Value`]) or types that register [`ReflectDeserialize`] type data,
308/// this `Box` will contain the expected type.
309/// For example, deserializing an `i32` will return a `Box<i32>` (as a `Box<dyn Reflect>`).
310///
311/// Otherwise, this `Box` will contain the dynamic equivalent.
312/// For example, a deserialized struct might return a [`Box<DynamicStruct>`]
313/// and a deserialized `Vec` might return a [`Box<DynamicList>`].
314///
315/// This means that if the actual type is needed, these dynamic representations will need to
316/// be converted to the concrete type using [`FromReflect`] or [`ReflectFromReflect`].
317///
318/// # Example
319///
320/// ```
321/// # use serde::de::DeserializeSeed;
322/// # use bevy_reflect::prelude::*;
323/// # use bevy_reflect::{DynamicStruct, TypeRegistry, serde::ReflectDeserializer};
324/// #[derive(Reflect, PartialEq, Debug)]
325/// #[type_path = "my_crate"]
326/// struct MyStruct {
327///   value: i32
328/// }
329///
330/// let mut registry = TypeRegistry::default();
331/// registry.register::<MyStruct>();
332///
333/// let input = r#"{
334///   "my_crate::MyStruct": (
335///     value: 123
336///   )
337/// }"#;
338///
339/// let mut deserializer = ron::Deserializer::from_str(input).unwrap();
340/// let reflect_deserializer = ReflectDeserializer::new(&registry);
341///
342/// let output: Box<dyn Reflect> = reflect_deserializer.deserialize(&mut deserializer).unwrap();
343///
344/// // Since `MyStruct` is not a value type and does not register `ReflectDeserialize`,
345/// // we know that its deserialized representation will be a `DynamicStruct`.
346/// assert!(output.is::<DynamicStruct>());
347/// assert!(output.represents::<MyStruct>());
348///
349/// // We can convert back to `MyStruct` using `FromReflect`.
350/// let value: MyStruct = <MyStruct as FromReflect>::from_reflect(&*output).unwrap();
351/// assert_eq!(value, MyStruct { value: 123 });
352///
353/// // We can also do this dynamically with `ReflectFromReflect`.
354/// let type_id = output.get_represented_type_info().unwrap().type_id();
355/// let reflect_from_reflect = registry.get_type_data::<ReflectFromReflect>(type_id).unwrap();
356/// let value: Box<dyn Reflect> = reflect_from_reflect.from_reflect(&*output).unwrap();
357/// assert!(value.is::<MyStruct>());
358/// assert_eq!(value.take::<MyStruct>().unwrap(), MyStruct { value: 123 });
359/// ```
360///
361/// [`ReflectSerializer`]: crate::serde::ReflectSerializer
362/// [type path]: crate::TypePath::type_path
363/// [`Box<dyn Reflect>`]: crate::Reflect
364/// [`ReflectKind::Value`]: crate::ReflectKind::Value
365/// [`ReflectDeserialize`]: crate::ReflectDeserialize
366/// [`Box<DynamicStruct>`]: crate::DynamicStruct
367/// [`Box<DynamicList>`]: crate::DynamicList
368/// [`FromReflect`]: crate::FromReflect
369/// [`ReflectFromReflect`]: crate::ReflectFromReflect
370pub struct ReflectDeserializer<'a> {
371    registry: &'a TypeRegistry,
372}
373
374impl<'a> ReflectDeserializer<'a> {
375    pub fn new(registry: &'a TypeRegistry) -> Self {
376        Self { registry }
377    }
378}
379
380impl<'a, 'de> DeserializeSeed<'de> for ReflectDeserializer<'a> {
381    type Value = Box<dyn Reflect>;
382
383    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
384    where
385        D: serde::Deserializer<'de>,
386    {
387        struct UntypedReflectDeserializerVisitor<'a> {
388            registry: &'a TypeRegistry,
389        }
390
391        impl<'a, 'de> Visitor<'de> for UntypedReflectDeserializerVisitor<'a> {
392            type Value = Box<dyn Reflect>;
393
394            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
395                formatter
396                    .write_str("map containing `type` and `value` entries for the reflected value")
397            }
398
399            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
400            where
401                A: MapAccess<'de>,
402            {
403                let registration = map
404                    .next_key_seed(TypeRegistrationDeserializer::new(self.registry))?
405                    .ok_or_else(|| Error::invalid_length(0, &"a single entry"))?;
406
407                let value = map.next_value_seed(TypedReflectDeserializer {
408                    registration,
409                    registry: self.registry,
410                })?;
411
412                if map.next_key::<IgnoredAny>()?.is_some() {
413                    return Err(Error::invalid_length(2, &"a single entry"));
414                }
415
416                Ok(value)
417            }
418        }
419
420        deserializer.deserialize_map(UntypedReflectDeserializerVisitor {
421            registry: self.registry,
422        })
423    }
424}
425
426/// A deserializer for reflected types whose [`TypeRegistration`] is known.
427///
428/// This is the deserializer counterpart to [`TypedReflectSerializer`].
429///
430/// See [`ReflectDeserializer`] for a deserializer that expects an unknown type.
431///
432/// # Input
433///
434/// Since the type is already known, the input is just the serialized data.
435///
436/// # Output
437///
438/// This deserializer will return a [`Box<dyn Reflect>`] containing the deserialized data.
439///
440/// For value types (i.e. [`ReflectKind::Value`]) or types that register [`ReflectDeserialize`] type data,
441/// this `Box` will contain the expected type.
442/// For example, deserializing an `i32` will return a `Box<i32>` (as a `Box<dyn Reflect>`).
443///
444/// Otherwise, this `Box` will contain the dynamic equivalent.
445/// For example, a deserialized struct might return a [`Box<DynamicStruct>`]
446/// and a deserialized `Vec` might return a [`Box<DynamicList>`].
447///
448/// This means that if the actual type is needed, these dynamic representations will need to
449/// be converted to the concrete type using [`FromReflect`] or [`ReflectFromReflect`].
450///
451/// # Example
452///
453/// ```
454/// # use std::any::TypeId;
455/// # use serde::de::DeserializeSeed;
456/// # use bevy_reflect::prelude::*;
457/// # use bevy_reflect::{DynamicStruct, TypeRegistry, serde::TypedReflectDeserializer};
458/// #[derive(Reflect, PartialEq, Debug)]
459/// struct MyStruct {
460///   value: i32
461/// }
462///
463/// let mut registry = TypeRegistry::default();
464/// registry.register::<MyStruct>();
465///
466/// let input = r#"(
467///   value: 123
468/// )"#;
469///
470/// let registration = registry.get(TypeId::of::<MyStruct>()).unwrap();
471///
472/// let mut deserializer = ron::Deserializer::from_str(input).unwrap();
473/// let reflect_deserializer = TypedReflectDeserializer::new(registration, &registry);
474///
475/// let output: Box<dyn Reflect> = reflect_deserializer.deserialize(&mut deserializer).unwrap();
476///
477/// // Since `MyStruct` is not a value type and does not register `ReflectDeserialize`,
478/// // we know that its deserialized representation will be a `DynamicStruct`.
479/// assert!(output.is::<DynamicStruct>());
480/// assert!(output.represents::<MyStruct>());
481///
482/// // We can convert back to `MyStruct` using `FromReflect`.
483/// let value: MyStruct = <MyStruct as FromReflect>::from_reflect(&*output).unwrap();
484/// assert_eq!(value, MyStruct { value: 123 });
485///
486/// // We can also do this dynamically with `ReflectFromReflect`.
487/// let type_id = output.get_represented_type_info().unwrap().type_id();
488/// let reflect_from_reflect = registry.get_type_data::<ReflectFromReflect>(type_id).unwrap();
489/// let value: Box<dyn Reflect> = reflect_from_reflect.from_reflect(&*output).unwrap();
490/// assert!(value.is::<MyStruct>());
491/// assert_eq!(value.take::<MyStruct>().unwrap(), MyStruct { value: 123 });
492/// ```
493///
494/// [`TypedReflectSerializer`]: crate::serde::TypedReflectSerializer
495/// [`Box<dyn Reflect>`]: crate::Reflect
496/// [`ReflectKind::Value`]: crate::ReflectKind::Value
497/// [`ReflectDeserialize`]: crate::ReflectDeserialize
498/// [`Box<DynamicStruct>`]: crate::DynamicStruct
499/// [`Box<DynamicList>`]: crate::DynamicList
500/// [`FromReflect`]: crate::FromReflect
501/// [`ReflectFromReflect`]: crate::ReflectFromReflect
502pub struct TypedReflectDeserializer<'a> {
503    registration: &'a TypeRegistration,
504    registry: &'a TypeRegistry,
505}
506
507impl<'a> TypedReflectDeserializer<'a> {
508    pub fn new(registration: &'a TypeRegistration, registry: &'a TypeRegistry) -> Self {
509        Self {
510            registration,
511            registry,
512        }
513    }
514}
515
516impl<'a, 'de> DeserializeSeed<'de> for TypedReflectDeserializer<'a> {
517    type Value = Box<dyn Reflect>;
518
519    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
520    where
521        D: serde::Deserializer<'de>,
522    {
523        let type_path = self.registration.type_info().type_path();
524
525        // Handle both Value case and types that have a custom `ReflectDeserialize`
526        if let Some(deserialize_reflect) = self.registration.data::<ReflectDeserialize>() {
527            let value = deserialize_reflect.deserialize(deserializer)?;
528            return Ok(value);
529        }
530
531        match self.registration.type_info() {
532            TypeInfo::Struct(struct_info) => {
533                let mut dynamic_struct = deserializer.deserialize_struct(
534                    struct_info.type_path_table().ident().unwrap(),
535                    struct_info.field_names(),
536                    StructVisitor {
537                        struct_info,
538                        registration: self.registration,
539                        registry: self.registry,
540                    },
541                )?;
542                dynamic_struct.set_represented_type(Some(self.registration.type_info()));
543                Ok(Box::new(dynamic_struct))
544            }
545            TypeInfo::TupleStruct(tuple_struct_info) => {
546                let mut dynamic_tuple_struct = deserializer.deserialize_tuple_struct(
547                    tuple_struct_info.type_path_table().ident().unwrap(),
548                    tuple_struct_info.field_len(),
549                    TupleStructVisitor {
550                        tuple_struct_info,
551                        registry: self.registry,
552                        registration: self.registration,
553                    },
554                )?;
555                dynamic_tuple_struct.set_represented_type(Some(self.registration.type_info()));
556                Ok(Box::new(dynamic_tuple_struct))
557            }
558            TypeInfo::List(list_info) => {
559                let mut dynamic_list = deserializer.deserialize_seq(ListVisitor {
560                    list_info,
561                    registry: self.registry,
562                })?;
563                dynamic_list.set_represented_type(Some(self.registration.type_info()));
564                Ok(Box::new(dynamic_list))
565            }
566            TypeInfo::Array(array_info) => {
567                let mut dynamic_array = deserializer.deserialize_tuple(
568                    array_info.capacity(),
569                    ArrayVisitor {
570                        array_info,
571                        registry: self.registry,
572                    },
573                )?;
574                dynamic_array.set_represented_type(Some(self.registration.type_info()));
575                Ok(Box::new(dynamic_array))
576            }
577            TypeInfo::Map(map_info) => {
578                let mut dynamic_map = deserializer.deserialize_map(MapVisitor {
579                    map_info,
580                    registry: self.registry,
581                })?;
582                dynamic_map.set_represented_type(Some(self.registration.type_info()));
583                Ok(Box::new(dynamic_map))
584            }
585            TypeInfo::Tuple(tuple_info) => {
586                let mut dynamic_tuple = deserializer.deserialize_tuple(
587                    tuple_info.field_len(),
588                    TupleVisitor {
589                        tuple_info,
590                        registration: self.registration,
591                        registry: self.registry,
592                    },
593                )?;
594                dynamic_tuple.set_represented_type(Some(self.registration.type_info()));
595                Ok(Box::new(dynamic_tuple))
596            }
597            TypeInfo::Enum(enum_info) => {
598                let mut dynamic_enum = if enum_info.type_path_table().module_path()
599                    == Some("core::option")
600                    && enum_info.type_path_table().ident() == Some("Option")
601                {
602                    deserializer.deserialize_option(OptionVisitor {
603                        enum_info,
604                        registry: self.registry,
605                    })?
606                } else {
607                    deserializer.deserialize_enum(
608                        enum_info.type_path_table().ident().unwrap(),
609                        enum_info.variant_names(),
610                        EnumVisitor {
611                            enum_info,
612                            registration: self.registration,
613                            registry: self.registry,
614                        },
615                    )?
616                };
617                dynamic_enum.set_represented_type(Some(self.registration.type_info()));
618                Ok(Box::new(dynamic_enum))
619            }
620            TypeInfo::Value(_) => {
621                // This case should already be handled
622                Err(Error::custom(format_args!(
623                    "the TypeRegistration for {type_path} doesn't have ReflectDeserialize",
624                )))
625            }
626        }
627    }
628}
629
630struct StructVisitor<'a> {
631    struct_info: &'static StructInfo,
632    registration: &'a TypeRegistration,
633    registry: &'a TypeRegistry,
634}
635
636impl<'a, 'de> Visitor<'de> for StructVisitor<'a> {
637    type Value = DynamicStruct;
638
639    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
640        formatter.write_str("reflected struct value")
641    }
642
643    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
644    where
645        A: SeqAccess<'de>,
646    {
647        visit_struct_seq(&mut seq, self.struct_info, self.registration, self.registry)
648    }
649
650    fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
651    where
652        V: MapAccess<'de>,
653    {
654        visit_struct(&mut map, self.struct_info, self.registration, self.registry)
655    }
656}
657
658struct TupleStructVisitor<'a> {
659    tuple_struct_info: &'static TupleStructInfo,
660    registry: &'a TypeRegistry,
661    registration: &'a TypeRegistration,
662}
663
664impl<'a, 'de> Visitor<'de> for TupleStructVisitor<'a> {
665    type Value = DynamicTupleStruct;
666
667    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
668        formatter.write_str("reflected tuple struct value")
669    }
670
671    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
672    where
673        V: SeqAccess<'de>,
674    {
675        visit_tuple(
676            &mut seq,
677            self.tuple_struct_info,
678            self.registration,
679            self.registry,
680        )
681        .map(DynamicTupleStruct::from)
682    }
683}
684
685struct TupleVisitor<'a> {
686    tuple_info: &'static TupleInfo,
687    registration: &'a TypeRegistration,
688    registry: &'a TypeRegistry,
689}
690
691impl<'a, 'de> Visitor<'de> for TupleVisitor<'a> {
692    type Value = DynamicTuple;
693
694    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
695        formatter.write_str("reflected tuple value")
696    }
697
698    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
699    where
700        V: SeqAccess<'de>,
701    {
702        visit_tuple(&mut seq, self.tuple_info, self.registration, self.registry)
703    }
704}
705
706struct ArrayVisitor<'a> {
707    array_info: &'static ArrayInfo,
708    registry: &'a TypeRegistry,
709}
710
711impl<'a, 'de> Visitor<'de> for ArrayVisitor<'a> {
712    type Value = DynamicArray;
713
714    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
715        formatter.write_str("reflected array value")
716    }
717
718    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
719    where
720        V: SeqAccess<'de>,
721    {
722        let mut vec = Vec::with_capacity(seq.size_hint().unwrap_or_default());
723        let registration = get_registration(
724            self.array_info.item_type_id(),
725            self.array_info.item_type_path_table().path(),
726            self.registry,
727        )?;
728        while let Some(value) = seq.next_element_seed(TypedReflectDeserializer {
729            registration,
730            registry: self.registry,
731        })? {
732            vec.push(value);
733        }
734
735        if vec.len() != self.array_info.capacity() {
736            return Err(Error::invalid_length(
737                vec.len(),
738                &self.array_info.capacity().to_string().as_str(),
739            ));
740        }
741
742        Ok(DynamicArray::new(vec.into_boxed_slice()))
743    }
744}
745
746struct ListVisitor<'a> {
747    list_info: &'static ListInfo,
748    registry: &'a TypeRegistry,
749}
750
751impl<'a, 'de> Visitor<'de> for ListVisitor<'a> {
752    type Value = DynamicList;
753
754    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
755        formatter.write_str("reflected list value")
756    }
757
758    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
759    where
760        V: SeqAccess<'de>,
761    {
762        let mut list = DynamicList::default();
763        let registration = get_registration(
764            self.list_info.item_type_id(),
765            self.list_info.item_type_path_table().path(),
766            self.registry,
767        )?;
768        while let Some(value) = seq.next_element_seed(TypedReflectDeserializer {
769            registration,
770            registry: self.registry,
771        })? {
772            list.push_box(value);
773        }
774        Ok(list)
775    }
776}
777
778struct MapVisitor<'a> {
779    map_info: &'static MapInfo,
780    registry: &'a TypeRegistry,
781}
782
783impl<'a, 'de> Visitor<'de> for MapVisitor<'a> {
784    type Value = DynamicMap;
785
786    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
787        formatter.write_str("reflected map value")
788    }
789
790    fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
791    where
792        V: MapAccess<'de>,
793    {
794        let mut dynamic_map = DynamicMap::default();
795        let key_registration = get_registration(
796            self.map_info.key_type_id(),
797            self.map_info.key_type_path_table().path(),
798            self.registry,
799        )?;
800        let value_registration = get_registration(
801            self.map_info.value_type_id(),
802            self.map_info.value_type_path_table().path(),
803            self.registry,
804        )?;
805        while let Some(key) = map.next_key_seed(TypedReflectDeserializer {
806            registration: key_registration,
807            registry: self.registry,
808        })? {
809            let value = map.next_value_seed(TypedReflectDeserializer {
810                registration: value_registration,
811                registry: self.registry,
812            })?;
813            dynamic_map.insert_boxed(key, value);
814        }
815
816        Ok(dynamic_map)
817    }
818}
819
820struct EnumVisitor<'a> {
821    enum_info: &'static EnumInfo,
822    registration: &'a TypeRegistration,
823    registry: &'a TypeRegistry,
824}
825
826impl<'a, 'de> Visitor<'de> for EnumVisitor<'a> {
827    type Value = DynamicEnum;
828
829    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
830        formatter.write_str("reflected enum value")
831    }
832
833    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
834    where
835        A: EnumAccess<'de>,
836    {
837        let mut dynamic_enum = DynamicEnum::default();
838        let (variant_info, variant) = data.variant_seed(VariantDeserializer {
839            enum_info: self.enum_info,
840        })?;
841
842        let value: DynamicVariant = match variant_info {
843            VariantInfo::Unit(..) => variant.unit_variant()?.into(),
844            VariantInfo::Struct(struct_info) => variant
845                .struct_variant(
846                    struct_info.field_names(),
847                    StructVariantVisitor {
848                        struct_info,
849                        registration: self.registration,
850                        registry: self.registry,
851                    },
852                )?
853                .into(),
854            VariantInfo::Tuple(tuple_info) if tuple_info.field_len() == 1 => {
855                let registration = tuple_info.get_field_registration(0, self.registry)?;
856                let value = variant.newtype_variant_seed(TypedReflectDeserializer {
857                    registration,
858                    registry: self.registry,
859                })?;
860                let mut dynamic_tuple = DynamicTuple::default();
861                dynamic_tuple.insert_boxed(value);
862                dynamic_tuple.into()
863            }
864            VariantInfo::Tuple(tuple_info) => variant
865                .tuple_variant(
866                    tuple_info.field_len(),
867                    TupleVariantVisitor {
868                        tuple_info,
869                        registration: self.registration,
870                        registry: self.registry,
871                    },
872                )?
873                .into(),
874        };
875        let variant_name = variant_info.name();
876        let variant_index = self
877            .enum_info
878            .index_of(variant_name)
879            .expect("variant should exist");
880        dynamic_enum.set_variant_with_index(variant_index, variant_name, value);
881        Ok(dynamic_enum)
882    }
883}
884
885struct VariantDeserializer {
886    enum_info: &'static EnumInfo,
887}
888
889impl<'de> DeserializeSeed<'de> for VariantDeserializer {
890    type Value = &'static VariantInfo;
891
892    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
893    where
894        D: serde::Deserializer<'de>,
895    {
896        struct VariantVisitor(&'static EnumInfo);
897
898        impl<'de> Visitor<'de> for VariantVisitor {
899            type Value = &'static VariantInfo;
900
901            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
902                formatter.write_str("expected either a variant index or variant name")
903            }
904
905            fn visit_u32<E>(self, variant_index: u32) -> Result<Self::Value, E>
906            where
907                E: Error,
908            {
909                self.0.variant_at(variant_index as usize).ok_or_else(|| {
910                    Error::custom(format_args!(
911                        "no variant found at index `{}` on enum `{}`",
912                        variant_index,
913                        self.0.type_path()
914                    ))
915                })
916            }
917
918            fn visit_str<E>(self, variant_name: &str) -> Result<Self::Value, E>
919            where
920                E: Error,
921            {
922                self.0.variant(variant_name).ok_or_else(|| {
923                    let names = self.0.iter().map(|variant| variant.name());
924                    Error::custom(format_args!(
925                        "unknown variant `{}`, expected one of {:?}",
926                        variant_name,
927                        ExpectedValues(names.collect())
928                    ))
929                })
930            }
931        }
932
933        deserializer.deserialize_identifier(VariantVisitor(self.enum_info))
934    }
935}
936
937struct StructVariantVisitor<'a> {
938    struct_info: &'static StructVariantInfo,
939    registration: &'a TypeRegistration,
940    registry: &'a TypeRegistry,
941}
942
943impl<'a, 'de> Visitor<'de> for StructVariantVisitor<'a> {
944    type Value = DynamicStruct;
945
946    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
947        formatter.write_str("reflected struct variant value")
948    }
949
950    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
951    where
952        A: SeqAccess<'de>,
953    {
954        visit_struct_seq(&mut seq, self.struct_info, self.registration, self.registry)
955    }
956
957    fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
958    where
959        V: MapAccess<'de>,
960    {
961        visit_struct(&mut map, self.struct_info, self.registration, self.registry)
962    }
963}
964
965struct TupleVariantVisitor<'a> {
966    tuple_info: &'static TupleVariantInfo,
967    registration: &'a TypeRegistration,
968    registry: &'a TypeRegistry,
969}
970
971impl<'a, 'de> Visitor<'de> for TupleVariantVisitor<'a> {
972    type Value = DynamicTuple;
973
974    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
975        formatter.write_str("reflected tuple variant value")
976    }
977
978    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
979    where
980        V: SeqAccess<'de>,
981    {
982        visit_tuple(&mut seq, self.tuple_info, self.registration, self.registry)
983    }
984}
985
986struct OptionVisitor<'a> {
987    enum_info: &'static EnumInfo,
988    registry: &'a TypeRegistry,
989}
990
991impl<'a, 'de> Visitor<'de> for OptionVisitor<'a> {
992    type Value = DynamicEnum;
993
994    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
995        formatter.write_str("reflected option value of type ")?;
996        formatter.write_str(self.enum_info.type_path())
997    }
998
999    fn visit_none<E>(self) -> Result<Self::Value, E>
1000    where
1001        E: Error,
1002    {
1003        let mut option = DynamicEnum::default();
1004        option.set_variant("None", ());
1005        Ok(option)
1006    }
1007
1008    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1009    where
1010        D: serde::Deserializer<'de>,
1011    {
1012        let variant_info = self.enum_info.variant("Some").unwrap();
1013        match variant_info {
1014            VariantInfo::Tuple(tuple_info) if tuple_info.field_len() == 1 => {
1015                let field = tuple_info.field_at(0).unwrap();
1016                let registration =
1017                    get_registration(field.type_id(), field.type_path(), self.registry)?;
1018                let de = TypedReflectDeserializer {
1019                    registration,
1020                    registry: self.registry,
1021                };
1022                let mut value = DynamicTuple::default();
1023                value.insert_boxed(de.deserialize(deserializer)?);
1024                let mut option = DynamicEnum::default();
1025                option.set_variant("Some", value);
1026                Ok(option)
1027            }
1028            info => Err(Error::custom(format_args!(
1029                "invalid variant, expected `Some` but got `{}`",
1030                info.name()
1031            ))),
1032        }
1033    }
1034}
1035
1036fn visit_struct<'de, T, V>(
1037    map: &mut V,
1038    info: &'static T,
1039    registration: &TypeRegistration,
1040    registry: &TypeRegistry,
1041) -> Result<DynamicStruct, V::Error>
1042where
1043    T: StructLikeInfo,
1044    V: MapAccess<'de>,
1045{
1046    let mut dynamic_struct = DynamicStruct::default();
1047    while let Some(Ident(key)) = map.next_key::<Ident>()? {
1048        let field = info.get_field(&key).ok_or_else(|| {
1049            let fields = info.iter_fields().map(|field| field.name());
1050            Error::custom(format_args!(
1051                "unknown field `{}`, expected one of {:?}",
1052                key,
1053                ExpectedValues(fields.collect())
1054            ))
1055        })?;
1056        let registration = get_registration(field.type_id(), field.type_path(), registry)?;
1057        let value = map.next_value_seed(TypedReflectDeserializer {
1058            registration,
1059            registry,
1060        })?;
1061        dynamic_struct.insert_boxed(&key, value);
1062    }
1063
1064    if let Some(serialization_data) = registration.data::<SerializationData>() {
1065        for (skipped_index, skipped_field) in serialization_data.iter_skipped() {
1066            let Some(field) = info.field_at(*skipped_index) else {
1067                continue;
1068            };
1069            dynamic_struct.insert_boxed(field.name(), skipped_field.generate_default());
1070        }
1071    }
1072
1073    Ok(dynamic_struct)
1074}
1075
1076fn visit_tuple<'de, T, V>(
1077    seq: &mut V,
1078    info: &T,
1079    registration: &TypeRegistration,
1080    registry: &TypeRegistry,
1081) -> Result<DynamicTuple, V::Error>
1082where
1083    T: TupleLikeInfo + Container,
1084    V: SeqAccess<'de>,
1085{
1086    let mut tuple = DynamicTuple::default();
1087
1088    let len = info.get_field_len();
1089
1090    if len == 0 {
1091        // Handle empty tuple/tuple struct
1092        return Ok(tuple);
1093    }
1094
1095    let serialization_data = registration.data::<SerializationData>();
1096
1097    for index in 0..len {
1098        if let Some(value) = serialization_data.and_then(|data| data.generate_default(index)) {
1099            tuple.insert_boxed(value);
1100            continue;
1101        }
1102
1103        let value = seq
1104            .next_element_seed(TypedReflectDeserializer {
1105                registration: info.get_field_registration(index, registry)?,
1106                registry,
1107            })?
1108            .ok_or_else(|| Error::invalid_length(index, &len.to_string().as_str()))?;
1109        tuple.insert_boxed(value);
1110    }
1111
1112    Ok(tuple)
1113}
1114
1115fn visit_struct_seq<'de, T, V>(
1116    seq: &mut V,
1117    info: &T,
1118    registration: &TypeRegistration,
1119    registry: &TypeRegistry,
1120) -> Result<DynamicStruct, V::Error>
1121where
1122    T: StructLikeInfo + Container,
1123    V: SeqAccess<'de>,
1124{
1125    let mut dynamic_struct = DynamicStruct::default();
1126
1127    let len = info.get_field_len();
1128
1129    if len == 0 {
1130        // Handle unit structs
1131        return Ok(dynamic_struct);
1132    }
1133
1134    let serialization_data = registration.data::<SerializationData>();
1135
1136    for index in 0..len {
1137        let name = info.field_at(index).unwrap().name();
1138
1139        if serialization_data
1140            .map(|data| data.is_field_skipped(index))
1141            .unwrap_or_default()
1142        {
1143            if let Some(value) = serialization_data.unwrap().generate_default(index) {
1144                dynamic_struct.insert_boxed(name, value);
1145            }
1146            continue;
1147        }
1148
1149        let value = seq
1150            .next_element_seed(TypedReflectDeserializer {
1151                registration: info.get_field_registration(index, registry)?,
1152                registry,
1153            })?
1154            .ok_or_else(|| Error::invalid_length(index, &len.to_string().as_str()))?;
1155        dynamic_struct.insert_boxed(name, value);
1156    }
1157
1158    Ok(dynamic_struct)
1159}
1160
1161fn get_registration<'a, E: Error>(
1162    type_id: TypeId,
1163    type_path: &str,
1164    registry: &'a TypeRegistry,
1165) -> Result<&'a TypeRegistration, E> {
1166    let registration = registry.get(type_id).ok_or_else(|| {
1167        Error::custom(format_args!("no registration found for type `{type_path}`"))
1168    })?;
1169    Ok(registration)
1170}
1171
1172#[cfg(test)]
1173mod tests {
1174    use bincode::Options;
1175    use std::any::TypeId;
1176    use std::f32::consts::PI;
1177
1178    use serde::de::DeserializeSeed;
1179    use serde::Deserialize;
1180
1181    use bevy_utils::HashMap;
1182
1183    use crate as bevy_reflect;
1184    use crate::serde::{ReflectDeserializer, ReflectSerializer, TypedReflectDeserializer};
1185    use crate::{DynamicEnum, FromReflect, Reflect, ReflectDeserialize, TypeRegistry};
1186
1187    #[derive(Reflect, Debug, PartialEq)]
1188    struct MyStruct {
1189        primitive_value: i8,
1190        option_value: Option<String>,
1191        option_value_complex: Option<SomeStruct>,
1192        tuple_value: (f32, usize),
1193        list_value: Vec<i32>,
1194        array_value: [i32; 5],
1195        map_value: HashMap<u8, usize>,
1196        struct_value: SomeStruct,
1197        tuple_struct_value: SomeTupleStruct,
1198        unit_struct: SomeUnitStruct,
1199        unit_enum: SomeEnum,
1200        newtype_enum: SomeEnum,
1201        tuple_enum: SomeEnum,
1202        struct_enum: SomeEnum,
1203        ignored_struct: SomeIgnoredStruct,
1204        ignored_tuple_struct: SomeIgnoredTupleStruct,
1205        ignored_struct_variant: SomeIgnoredEnum,
1206        ignored_tuple_variant: SomeIgnoredEnum,
1207        custom_deserialize: CustomDeserialize,
1208    }
1209
1210    #[derive(Reflect, Debug, PartialEq)]
1211    struct SomeStruct {
1212        foo: i64,
1213    }
1214
1215    #[derive(Reflect, Debug, PartialEq)]
1216    struct SomeTupleStruct(String);
1217
1218    #[derive(Reflect, Debug, PartialEq)]
1219    struct SomeUnitStruct;
1220
1221    #[derive(Reflect, Debug, PartialEq)]
1222    struct SomeIgnoredStruct {
1223        #[reflect(ignore)]
1224        ignored: i32,
1225    }
1226
1227    #[derive(Reflect, Debug, PartialEq)]
1228    struct SomeIgnoredTupleStruct(#[reflect(ignore)] i32);
1229
1230    #[derive(Reflect, Debug, PartialEq, Deserialize)]
1231    struct SomeDeserializableStruct {
1232        foo: i64,
1233    }
1234
1235    /// Implements a custom deserialize using `#[reflect(Deserialize)]`.
1236    ///
1237    /// For testing purposes, this is just the auto-generated one from deriving.
1238    #[derive(Reflect, Debug, PartialEq, Deserialize)]
1239    #[reflect(Deserialize)]
1240    struct CustomDeserialize {
1241        value: usize,
1242        #[serde(alias = "renamed")]
1243        inner_struct: SomeDeserializableStruct,
1244    }
1245
1246    #[derive(Reflect, Debug, PartialEq)]
1247    enum SomeEnum {
1248        Unit,
1249        NewType(usize),
1250        Tuple(f32, f32),
1251        Struct { foo: String },
1252    }
1253
1254    #[derive(Reflect, Debug, PartialEq)]
1255    enum SomeIgnoredEnum {
1256        Tuple(#[reflect(ignore)] f32, #[reflect(ignore)] f32),
1257        Struct {
1258            #[reflect(ignore)]
1259            foo: String,
1260        },
1261    }
1262
1263    fn get_registry() -> TypeRegistry {
1264        let mut registry = TypeRegistry::default();
1265        registry.register::<MyStruct>();
1266        registry.register::<SomeStruct>();
1267        registry.register::<SomeTupleStruct>();
1268        registry.register::<SomeUnitStruct>();
1269        registry.register::<SomeIgnoredStruct>();
1270        registry.register::<SomeIgnoredTupleStruct>();
1271        registry.register::<CustomDeserialize>();
1272        registry.register::<SomeDeserializableStruct>();
1273        registry.register::<SomeEnum>();
1274        registry.register::<SomeIgnoredEnum>();
1275        registry.register::<i8>();
1276        registry.register::<String>();
1277        registry.register::<i64>();
1278        registry.register::<f32>();
1279        registry.register::<usize>();
1280        registry.register::<i32>();
1281        registry.register::<u8>();
1282        registry.register::<(f32, usize)>();
1283        registry.register::<[i32; 5]>();
1284        registry.register::<Vec<i32>>();
1285        registry.register::<HashMap<u8, usize>>();
1286        registry.register::<Option<SomeStruct>>();
1287        registry.register::<Option<String>>();
1288        registry.register_type_data::<Option<String>, ReflectDeserialize>();
1289        registry
1290    }
1291
1292    fn get_my_struct() -> MyStruct {
1293        let mut map = HashMap::new();
1294        map.insert(64, 32);
1295
1296        MyStruct {
1297            primitive_value: 123,
1298            option_value: Some(String::from("Hello world!")),
1299            option_value_complex: Some(SomeStruct { foo: 123 }),
1300            tuple_value: (PI, 1337),
1301            list_value: vec![-2, -1, 0, 1, 2],
1302            array_value: [-2, -1, 0, 1, 2],
1303            map_value: map,
1304            struct_value: SomeStruct { foo: 999999999 },
1305            tuple_struct_value: SomeTupleStruct(String::from("Tuple Struct")),
1306            unit_struct: SomeUnitStruct,
1307            unit_enum: SomeEnum::Unit,
1308            newtype_enum: SomeEnum::NewType(123),
1309            tuple_enum: SomeEnum::Tuple(1.23, 3.21),
1310            struct_enum: SomeEnum::Struct {
1311                foo: String::from("Struct variant value"),
1312            },
1313            ignored_struct: SomeIgnoredStruct { ignored: 0 },
1314            ignored_tuple_struct: SomeIgnoredTupleStruct(0),
1315            ignored_struct_variant: SomeIgnoredEnum::Struct {
1316                foo: String::default(),
1317            },
1318            ignored_tuple_variant: SomeIgnoredEnum::Tuple(0.0, 0.0),
1319            custom_deserialize: CustomDeserialize {
1320                value: 100,
1321                inner_struct: SomeDeserializableStruct { foo: 101 },
1322            },
1323        }
1324    }
1325
1326    #[test]
1327    fn should_deserialize() {
1328        let expected = get_my_struct();
1329        let registry = get_registry();
1330
1331        let input = r#"{
1332            "bevy_reflect::serde::de::tests::MyStruct": (
1333                primitive_value: 123,
1334                option_value: Some("Hello world!"),
1335                option_value_complex: Some((
1336                    foo: 123,
1337                )),
1338                tuple_value: (3.1415927, 1337),
1339                list_value: [
1340                    -2,
1341                    -1,
1342                    0,
1343                    1,
1344                    2,
1345                ],
1346                array_value: (-2, -1, 0, 1, 2),
1347                map_value: {
1348                    64: 32,
1349                },
1350                struct_value: (
1351                    foo: 999999999,
1352                ),
1353                tuple_struct_value: ("Tuple Struct"),
1354                unit_struct: (),
1355                unit_enum: Unit,
1356                newtype_enum: NewType(123),
1357                tuple_enum: Tuple(1.23, 3.21),
1358                struct_enum: Struct(
1359                    foo: "Struct variant value",
1360                ),
1361                ignored_struct: (),
1362                ignored_tuple_struct: (),
1363                ignored_struct_variant: Struct(),
1364                ignored_tuple_variant: Tuple(),
1365                custom_deserialize: (
1366                    value: 100,
1367                    renamed: (
1368                        foo: 101,
1369                    ),
1370                ),
1371            ),
1372        }"#;
1373
1374        let reflect_deserializer = ReflectDeserializer::new(&registry);
1375        let mut ron_deserializer = ron::de::Deserializer::from_str(input).unwrap();
1376        let dynamic_output = reflect_deserializer
1377            .deserialize(&mut ron_deserializer)
1378            .unwrap();
1379
1380        let output = <MyStruct as FromReflect>::from_reflect(dynamic_output.as_ref()).unwrap();
1381        assert_eq!(expected, output);
1382    }
1383
1384    #[test]
1385    fn should_deserialize_value() {
1386        let input = r#"{
1387            "f32": 1.23,
1388        }"#;
1389
1390        let registry = get_registry();
1391        let reflect_deserializer = ReflectDeserializer::new(&registry);
1392        let mut ron_deserializer = ron::de::Deserializer::from_str(input).unwrap();
1393        let dynamic_output = reflect_deserializer
1394            .deserialize(&mut ron_deserializer)
1395            .unwrap();
1396        let output = dynamic_output
1397            .take::<f32>()
1398            .expect("underlying type should be f32");
1399        assert_eq!(1.23, output);
1400    }
1401
1402    #[test]
1403    fn should_deserialized_typed() {
1404        #[derive(Reflect, Debug, PartialEq)]
1405        struct Foo {
1406            bar: i32,
1407        }
1408
1409        let expected = Foo { bar: 123 };
1410
1411        let input = r#"(
1412            bar: 123
1413        )"#;
1414
1415        let mut registry = get_registry();
1416        registry.register::<Foo>();
1417        let registration = registry.get(TypeId::of::<Foo>()).unwrap();
1418        let reflect_deserializer = TypedReflectDeserializer::new(registration, &registry);
1419        let mut ron_deserializer = ron::de::Deserializer::from_str(input).unwrap();
1420        let dynamic_output = reflect_deserializer
1421            .deserialize(&mut ron_deserializer)
1422            .unwrap();
1423
1424        let output = <Foo as FromReflect>::from_reflect(dynamic_output.as_ref()).unwrap();
1425        assert_eq!(expected, output);
1426    }
1427
1428    #[test]
1429    fn should_deserialize_option() {
1430        #[derive(Reflect, Debug, PartialEq)]
1431        struct OptionTest {
1432            none: Option<()>,
1433            simple: Option<String>,
1434            complex: Option<SomeStruct>,
1435        }
1436
1437        let expected = OptionTest {
1438            none: None,
1439            simple: Some(String::from("Hello world!")),
1440            complex: Some(SomeStruct { foo: 123 }),
1441        };
1442
1443        let mut registry = get_registry();
1444        registry.register::<OptionTest>();
1445        registry.register::<Option<()>>();
1446
1447        // === Normal === //
1448        let input = r#"{
1449            "bevy_reflect::serde::de::tests::OptionTest": (
1450                none: None,
1451                simple: Some("Hello world!"),
1452                complex: Some((
1453                    foo: 123,
1454                )),
1455            ),
1456        }"#;
1457
1458        let reflect_deserializer = ReflectDeserializer::new(&registry);
1459        let mut ron_deserializer = ron::de::Deserializer::from_str(input).unwrap();
1460        let dynamic_output = reflect_deserializer
1461            .deserialize(&mut ron_deserializer)
1462            .unwrap();
1463
1464        let output = <OptionTest as FromReflect>::from_reflect(dynamic_output.as_ref()).unwrap();
1465        assert_eq!(expected, output, "failed to deserialize Options");
1466
1467        // === Implicit Some === //
1468        let input = r#"
1469        #![enable(implicit_some)]
1470        {
1471            "bevy_reflect::serde::de::tests::OptionTest": (
1472                none: None,
1473                simple: "Hello world!",
1474                complex: (
1475                    foo: 123,
1476                ),
1477            ),
1478        }"#;
1479
1480        let reflect_deserializer = ReflectDeserializer::new(&registry);
1481        let mut ron_deserializer = ron::de::Deserializer::from_str(input).unwrap();
1482        let dynamic_output = reflect_deserializer
1483            .deserialize(&mut ron_deserializer)
1484            .unwrap();
1485
1486        let output = <OptionTest as FromReflect>::from_reflect(dynamic_output.as_ref()).unwrap();
1487        assert_eq!(
1488            expected, output,
1489            "failed to deserialize Options with implicit Some"
1490        );
1491    }
1492
1493    #[test]
1494    fn enum_should_deserialize() {
1495        #[derive(Reflect)]
1496        enum MyEnum {
1497            Unit,
1498            NewType(usize),
1499            Tuple(f32, f32),
1500            Struct { value: String },
1501        }
1502
1503        let mut registry = get_registry();
1504        registry.register::<MyEnum>();
1505
1506        // === Unit Variant === //
1507        let input = r#"{
1508    "bevy_reflect::serde::de::tests::MyEnum": Unit,
1509}"#;
1510        let reflect_deserializer = ReflectDeserializer::new(&registry);
1511        let mut deserializer = ron::de::Deserializer::from_str(input).unwrap();
1512        let output = reflect_deserializer.deserialize(&mut deserializer).unwrap();
1513
1514        let expected = DynamicEnum::from(MyEnum::Unit);
1515        assert!(expected.reflect_partial_eq(output.as_ref()).unwrap());
1516
1517        // === NewType Variant === //
1518        let input = r#"{
1519    "bevy_reflect::serde::de::tests::MyEnum": NewType(123),
1520}"#;
1521        let reflect_deserializer = ReflectDeserializer::new(&registry);
1522        let mut deserializer = ron::de::Deserializer::from_str(input).unwrap();
1523        let output = reflect_deserializer.deserialize(&mut deserializer).unwrap();
1524
1525        let expected = DynamicEnum::from(MyEnum::NewType(123));
1526        assert!(expected.reflect_partial_eq(output.as_ref()).unwrap());
1527
1528        // === Tuple Variant === //
1529        let input = r#"{
1530    "bevy_reflect::serde::de::tests::MyEnum": Tuple(1.23, 3.21),
1531}"#;
1532        let reflect_deserializer = ReflectDeserializer::new(&registry);
1533        let mut deserializer = ron::de::Deserializer::from_str(input).unwrap();
1534        let output = reflect_deserializer.deserialize(&mut deserializer).unwrap();
1535
1536        let expected = DynamicEnum::from(MyEnum::Tuple(1.23, 3.21));
1537        assert!(expected.reflect_partial_eq(output.as_ref()).unwrap());
1538
1539        // === Struct Variant === //
1540        let input = r#"{
1541    "bevy_reflect::serde::de::tests::MyEnum": Struct(
1542        value: "I <3 Enums",
1543    ),
1544}"#;
1545        let reflect_deserializer = ReflectDeserializer::new(&registry);
1546        let mut deserializer = ron::de::Deserializer::from_str(input).unwrap();
1547        let output = reflect_deserializer.deserialize(&mut deserializer).unwrap();
1548
1549        let expected = DynamicEnum::from(MyEnum::Struct {
1550            value: String::from("I <3 Enums"),
1551        });
1552        assert!(expected.reflect_partial_eq(output.as_ref()).unwrap());
1553    }
1554
1555    // Regression test for https://github.com/bevyengine/bevy/issues/12462
1556    #[test]
1557    fn should_reserialize() {
1558        let registry = get_registry();
1559        let input1 = get_my_struct();
1560
1561        let serializer1 = ReflectSerializer::new(&input1, &registry);
1562        let serialized1 = ron::ser::to_string(&serializer1).unwrap();
1563
1564        let mut deserializer = ron::de::Deserializer::from_str(&serialized1).unwrap();
1565        let reflect_deserializer = ReflectDeserializer::new(&registry);
1566        let input2 = reflect_deserializer.deserialize(&mut deserializer).unwrap();
1567
1568        let serializer2 = ReflectSerializer::new(&*input2, &registry);
1569        let serialized2 = ron::ser::to_string(&serializer2).unwrap();
1570
1571        assert_eq!(serialized1, serialized2);
1572    }
1573
1574    #[test]
1575    fn should_deserialize_non_self_describing_binary() {
1576        let expected = get_my_struct();
1577        let registry = get_registry();
1578
1579        let input = vec![
1580            1, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 98, 101, 118, 121, 95, 114, 101, 102,
1581            108, 101, 99, 116, 58, 58, 115, 101, 114, 100, 101, 58, 58, 100, 101, 58, 58, 116, 101,
1582            115, 116, 115, 58, 58, 77, 121, 83, 116, 114, 117, 99, 116, 123, 1, 12, 0, 0, 0, 0, 0,
1583            0, 0, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33, 1, 123, 0, 0, 0, 0, 0,
1584            0, 0, 219, 15, 73, 64, 57, 5, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255,
1585            255, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 254, 255, 255, 255, 255,
1586            255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 64, 32, 0,
1587            0, 0, 0, 0, 0, 0, 255, 201, 154, 59, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 84, 117, 112,
1588            108, 101, 32, 83, 116, 114, 117, 99, 116, 0, 0, 0, 0, 1, 0, 0, 0, 123, 0, 0, 0, 0, 0,
1589            0, 0, 2, 0, 0, 0, 164, 112, 157, 63, 164, 112, 77, 64, 3, 0, 0, 0, 20, 0, 0, 0, 0, 0,
1590            0, 0, 83, 116, 114, 117, 99, 116, 32, 118, 97, 114, 105, 97, 110, 116, 32, 118, 97,
1591            108, 117, 101, 1, 0, 0, 0, 0, 0, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 0, 0, 0,
1592            0,
1593        ];
1594
1595        let deserializer = ReflectDeserializer::new(&registry);
1596
1597        let dynamic_output = bincode::DefaultOptions::new()
1598            .with_fixint_encoding()
1599            .deserialize_seed(deserializer, &input)
1600            .unwrap();
1601
1602        let output = <MyStruct as FromReflect>::from_reflect(dynamic_output.as_ref()).unwrap();
1603        assert_eq!(expected, output);
1604    }
1605
1606    #[test]
1607    fn should_deserialize_self_describing_binary() {
1608        let expected = get_my_struct();
1609        let registry = get_registry();
1610
1611        let input = vec![
1612            129, 217, 40, 98, 101, 118, 121, 95, 114, 101, 102, 108, 101, 99, 116, 58, 58, 115,
1613            101, 114, 100, 101, 58, 58, 100, 101, 58, 58, 116, 101, 115, 116, 115, 58, 58, 77, 121,
1614            83, 116, 114, 117, 99, 116, 220, 0, 19, 123, 172, 72, 101, 108, 108, 111, 32, 119, 111,
1615            114, 108, 100, 33, 145, 123, 146, 202, 64, 73, 15, 219, 205, 5, 57, 149, 254, 255, 0,
1616            1, 2, 149, 254, 255, 0, 1, 2, 129, 64, 32, 145, 206, 59, 154, 201, 255, 145, 172, 84,
1617            117, 112, 108, 101, 32, 83, 116, 114, 117, 99, 116, 144, 164, 85, 110, 105, 116, 129,
1618            167, 78, 101, 119, 84, 121, 112, 101, 123, 129, 165, 84, 117, 112, 108, 101, 146, 202,
1619            63, 157, 112, 164, 202, 64, 77, 112, 164, 129, 166, 83, 116, 114, 117, 99, 116, 145,
1620            180, 83, 116, 114, 117, 99, 116, 32, 118, 97, 114, 105, 97, 110, 116, 32, 118, 97, 108,
1621            117, 101, 144, 144, 129, 166, 83, 116, 114, 117, 99, 116, 144, 129, 165, 84, 117, 112,
1622            108, 101, 144, 146, 100, 145, 101,
1623        ];
1624
1625        let mut reader = std::io::BufReader::new(input.as_slice());
1626
1627        let deserializer = ReflectDeserializer::new(&registry);
1628        let dynamic_output = deserializer
1629            .deserialize(&mut rmp_serde::Deserializer::new(&mut reader))
1630            .unwrap();
1631
1632        let output = <MyStruct as FromReflect>::from_reflect(dynamic_output.as_ref()).unwrap();
1633        assert_eq!(expected, output);
1634    }
1635}
bevy_reflect/serde/de.rs

bevy_reflect/serde/
de.rs
