Struct bevy_reflect::serde::ReflectDeserializer
source · pub struct ReflectDeserializer<'a> { /* private fields */ }
Expand description
A general purpose deserializer for reflected types.
This is the deserializer counterpart to ReflectSerializer
.
See TypedReflectDeserializer
for a deserializer that expects a known type.
§Input
This deserializer expects a map with a single entry, where the key is the full type path of the reflected type and the value is the serialized data.
§Output
This deserializer will return a Box<dyn Reflect>
containing the deserialized data.
For value types (i.e. ReflectKind::Value
) or types that register ReflectDeserialize
type data,
this Box
will contain the expected type.
For example, deserializing an i32
will return a Box<i32>
(as a Box<dyn Reflect>
).
Otherwise, this Box
will contain the dynamic equivalent.
For example, a deserialized struct might return a Box<DynamicStruct>
and a deserialized Vec
might return a Box<DynamicList>
.
This means that if the actual type is needed, these dynamic representations will need to
be converted to the concrete type using FromReflect
or ReflectFromReflect
.
§Example
#[derive(Reflect, PartialEq, Debug)]
#[type_path = "my_crate"]
struct MyStruct {
value: i32
}
let mut registry = TypeRegistry::default();
registry.register::<MyStruct>();
let input = r#"{
"my_crate::MyStruct": (
value: 123
)
}"#;
let mut deserializer = ron::Deserializer::from_str(input).unwrap();
let reflect_deserializer = ReflectDeserializer::new(®istry);
let output: Box<dyn Reflect> = reflect_deserializer.deserialize(&mut deserializer).unwrap();
// Since `MyStruct` is not a value type and does not register `ReflectDeserialize`,
// we know that its deserialized representation will be a `DynamicStruct`.
assert!(output.is::<DynamicStruct>());
assert!(output.represents::<MyStruct>());
// We can convert back to `MyStruct` using `FromReflect`.
let value: MyStruct = <MyStruct as FromReflect>::from_reflect(&*output).unwrap();
assert_eq!(value, MyStruct { value: 123 });
// We can also do this dynamically with `ReflectFromReflect`.
let type_id = output.get_represented_type_info().unwrap().type_id();
let reflect_from_reflect = registry.get_type_data::<ReflectFromReflect>(type_id).unwrap();
let value: Box<dyn Reflect> = reflect_from_reflect.from_reflect(&*output).unwrap();
assert!(value.is::<MyStruct>());
assert_eq!(value.take::<MyStruct>().unwrap(), MyStruct { value: 123 });
Implementations§
source§impl<'a> ReflectDeserializer<'a>
impl<'a> ReflectDeserializer<'a>
pub fn new(registry: &'a TypeRegistry) -> Self
Trait Implementations§
source§impl<'a, 'de> DeserializeSeed<'de> for ReflectDeserializer<'a>
impl<'a, 'de> DeserializeSeed<'de> for ReflectDeserializer<'a>
Auto Trait Implementations§
impl<'a> Freeze for ReflectDeserializer<'a>
impl<'a> !RefUnwindSafe for ReflectDeserializer<'a>
impl<'a> Send for ReflectDeserializer<'a>
impl<'a> Sync for ReflectDeserializer<'a>
impl<'a> Unpin for ReflectDeserializer<'a>
impl<'a> !UnwindSafe for ReflectDeserializer<'a>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.