Struct ReflectDeserializer

pub struct ReflectDeserializer<'a, 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) -> Self

Creates a deserializer with no processor.

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

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

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

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: ReflectDeserializerProcessor> DeserializeSeed<'de> for ReflectDeserializer<'_, P>

type Value = Box<dyn PartialReflect>

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.