Struct ReflectDeserializer 

pub struct ReflectDeserializer<'a, P = ()>
where
    P: ReflectDeserializerProcessor,
{ /* private fields */ }

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 opaque types (i.e. ReflectKind::Opaque) 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.

If you want to override deserialization for a specific TypeRegistration, you can pass in a reference to a ReflectDeserializerProcessor which will take priority over all other deserialization methods - see with_processor.

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(&registry);

let output: Box<dyn PartialReflect> = reflect_deserializer.deserialize(&mut deserializer).unwrap();

// Since `MyStruct` is not an opaque type and does not register `ReflectDeserialize`,
// we know that its deserialized value will be a `DynamicStruct`,
// although it will represent `MyStruct`.
assert!(output.as_partial_reflect().represents::<MyStruct>());

// We can convert back to `MyStruct` using `FromReflect`.
let value: MyStruct = <MyStruct as FromReflect>::from_reflect(output.as_partial_reflect()).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.as_partial_reflect()).unwrap();
assert!(value.is::<MyStruct>());
assert_eq!(value.take::<MyStruct>().unwrap(), MyStruct { value: 123 });

Implementations

impl<'a> ReflectDeserializer<'a>

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

Creates a deserializer with no processor.

If you want to add custom logic for deserializing certain types, use with_processor.

Examples found in repository

examples/reflection/serialization.rs (line 43)

fn deserialize(type_registry: Res<AppTypeRegistry>) {
    let type_registry = type_registry.read();

    // a serde_json::Value that might have come from an API
    let value: serde_json::Value = serde_json::from_str(PLAYER_JSON).unwrap();

    // alternatively, `TypedReflectDeserializer` can be used if the type
    // is known.
    let deserializer = ReflectDeserializer::new(&type_registry);
    // deserialize
    let reflect_value = deserializer.deserialize(value).unwrap();
    // If Player implemented additional functionality, like Component,
    // this reflect_value could be used with commands.insert_reflect
    info!(?reflect_value);
}

examples/reflection/reflection.rs (line 99)

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 PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_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 PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // 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);
}

impl<'a, P> ReflectDeserializer<'a, P>

where P: ReflectDeserializerProcessor,

pub fn with_processor( registry: &'a TypeRegistry, processor: &'a mut P, ) -> ReflectDeserializer<'a, P>

Creates a deserializer with a processor.

If you do not need any custom logic for handling certain types, use new.

Trait Implementations

impl<'de, P> DeserializeSeed<'de> for ReflectDeserializer<'_, P>

where P: ReflectDeserializerProcessor,

type Value = Box<dyn PartialReflect>

The type produced by using this seed.

fn deserialize<D>( self, deserializer: D, ) -> Result<<ReflectDeserializer<'_, P> 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.