Struct bevy_reflect::serde::ReflectDeserializer

pub struct ReflectDeserializer<'a> { /* 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 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(&registry);

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>

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

Trait Implementations

impl<'a, 'de> DeserializeSeed<'de> for ReflectDeserializer<'a>

type Value = Box<dyn Reflect>

The type produced by using this seed.

fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>

where D: Deserializer<'de>,

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