Struct bevy::reflect::serde::UntypedReflectDeserializer

pub struct UntypedReflectDeserializer<'a> { /* private fields */ }

A general purpose deserializer for reflected types.

This will return a Box<dyn Reflect> containing the deserialized data. For non-value types, this Box will contain the dynamic equivalent. For example, a deserialized struct will return a DynamicStruct and a Vec will return a DynamicList. For value types, this Box will contain the actual value. For example, an f32 will contain the actual f32 type.

This means that converting to any concrete instance will require the use of FromReflect, or downcasting for value types.

Because the type isn’t known ahead of time, the serialized data must take the form of a map containing the following entries (in order):

1. type: The full type path
2. value: The serialized value of the reflected type

If the type is already known and the TypeInfo for it can be retrieved, TypedReflectDeserializer may be used instead to avoid requiring these entries.

Implementations

impl<'a> UntypedReflectDeserializer<'a>

pub fn new(registry: &'a TypeRegistry) -> UntypedReflectDeserializer<'a>

Examples found in repository

examples/reflection/reflection.rs (line 93)

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 = UntypedReflectDeserializer::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 UntypedReflectDeserializer<'a>

type Value = Box<dyn Reflect>

The type produced by using this seed.

fn deserialize<D>( self, deserializer: D ) -> Result<<UntypedReflectDeserializer<'a> as DeserializeSeed<'de>>::Value, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Equivalent to the more common Deserialize::deserialize method, except with some initial piece of data (the seed) passed in.