Struct TypedReflectDeserializer

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

A deserializer for reflected types whose TypeRegistration is known.

This is the deserializer counterpart to TypedReflectSerializer.

See ReflectDeserializer for a deserializer that expects an unknown type.

Input

Since the type is already known, the input is just 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)]
struct MyStruct {
  value: i32
}

let mut registry = TypeRegistry::default();
registry.register::<MyStruct>();

let input = r#"(
  value: 123
)"#;

let registration = registry.get(TypeId::of::<MyStruct>()).unwrap();

let mut deserializer = ron::Deserializer::from_str(input).unwrap();
let reflect_deserializer = TypedReflectDeserializer::new(registration, &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> TypedReflectDeserializer<'a>

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

Trait Implementations

impl<'a, 'de> DeserializeSeed<'de> for TypedReflectDeserializer<'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.