Struct bevy::reflect::serde::ReflectDeserializer
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§
§impl<'a> ReflectDeserializer<'a>
impl<'a> ReflectDeserializer<'a>
pub fn new(registry: &'a TypeRegistry) -> ReflectDeserializer<'a>
pub fn new(registry: &'a TypeRegistry) -> ReflectDeserializer<'a>
Examples found in repository?
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
fn setup(type_registry: Res<AppTypeRegistry>) {
let mut value = Foo {
a: 1,
_ignored: NonReflectedValue { _a: 10 },
nested: Bar { b: 8 },
};
// You can set field values like this. The type must match exactly or this will fail.
*value.get_field_mut("a").unwrap() = 2usize;
assert_eq!(value.a, 2);
assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);
// You can also get the &dyn Reflect value of a field like this
let field = value.field("a").unwrap();
// you can downcast Reflect values like this:
assert_eq!(*field.downcast_ref::<usize>().unwrap(), 2);
// DynamicStruct also implements the `Struct` and `Reflect` traits.
let mut patch = DynamicStruct::default();
patch.insert("a", 4usize);
// You can "apply" Reflect implementations on top of other Reflect implementations.
// This will only set fields with the same name, and it will fail if the types don't match.
// You can use this to "patch" your types with new values.
value.apply(&patch);
assert_eq!(value.a, 4);
let type_registry = type_registry.read();
// By default, all derived `Reflect` types can be Serialized using serde. No need to derive
// Serialize!
let serializer = ReflectSerializer::new(&value, &type_registry);
let ron_string =
ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
info!("{}\n", ron_string);
// Dynamic properties can be deserialized
let reflect_deserializer = ReflectDeserializer::new(&type_registry);
let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();
// Deserializing returns a Box<dyn Reflect> value. Generally, deserializing a value will return
// the "dynamic" variant of a type. For example, deserializing a struct will return the
// DynamicStruct type. "Value types" will be deserialized as themselves.
let _deserialized_struct = reflect_value.downcast_ref::<DynamicStruct>();
// Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
// like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
// `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
assert!(reflect_value.reflect_partial_eq(&value).unwrap());
// By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
// This means we can serialize and deserialize with a single `Reflect` derive!
value.apply(&*reflect_value);
}
Trait Implementations§
§impl<'a, 'de> DeserializeSeed<'de> for ReflectDeserializer<'a>
impl<'a, 'de> DeserializeSeed<'de> for ReflectDeserializer<'a>
§fn deserialize<D>(
self,
deserializer: D
) -> Result<<ReflectDeserializer<'a> as DeserializeSeed<'de>>::Value, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
self,
deserializer: D
) -> Result<<ReflectDeserializer<'a> as DeserializeSeed<'de>>::Value, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
Deserialize::deserialize
method, except
with some initial piece of data (the seed) passed in.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§
§impl<T, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
§fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
T
ShaderType
for self
. When used in AsBindGroup
derives, it is safe to assume that all images in self
exist.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
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§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
.§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
.§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.§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.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more