Struct bevy_reflect::serde::TypedReflectDeserializer
source · pub struct TypedReflectDeserializer<'a> { /* private fields */ }
Expand description
A deserializer for reflected types whose TypeRegistration
is known.
This is the deserializer counterpart to TypedReflectSerializer
.
See ReflectDeserializer
for a deserializer that expects an unknown type.
§Input
Since the type is already known, the input is just 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)]
struct MyStruct {
value: i32
}
let mut registry = TypeRegistry::default();
registry.register::<MyStruct>();
let input = r#"(
value: 123
)"#;
let registration = registry.get(TypeId::of::<MyStruct>()).unwrap();
let mut deserializer = ron::Deserializer::from_str(input).unwrap();
let reflect_deserializer = TypedReflectDeserializer::new(registration, ®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> TypedReflectDeserializer<'a>
impl<'a> TypedReflectDeserializer<'a>
pub fn new( registration: &'a TypeRegistration, registry: &'a TypeRegistry ) -> Self
Trait Implementations§
source§impl<'a, 'de> DeserializeSeed<'de> for TypedReflectDeserializer<'a>
impl<'a, 'de> DeserializeSeed<'de> for TypedReflectDeserializer<'a>
Auto Trait Implementations§
impl<'a> Freeze for TypedReflectDeserializer<'a>
impl<'a> !RefUnwindSafe for TypedReflectDeserializer<'a>
impl<'a> Send for TypedReflectDeserializer<'a>
impl<'a> Sync for TypedReflectDeserializer<'a>
impl<'a> Unpin for TypedReflectDeserializer<'a>
impl<'a> !UnwindSafe for TypedReflectDeserializer<'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.