Struct TypedReflectDeserializer 

pub struct TypedReflectDeserializer<'a, P = ()>
where
    P: ReflectDeserializerProcessor,
{ /* 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 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)]
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 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> TypedReflectDeserializer<'a>

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

Creates a typed deserializer with no processor.

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

pub fn of<T>(registry: &'a TypeRegistry) -> TypedReflectDeserializer<'a>

where T: TypePath,

Creates a new TypedReflectDeserializer for the given type T without a processor.

Panics

Panics if T is not registered in the given TypeRegistry.

impl<'a, P> TypedReflectDeserializer<'a, P>

where P: ReflectDeserializerProcessor,

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

Creates a typed 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 TypedReflectDeserializer<'_, P>

where P: ReflectDeserializerProcessor,

type Value = Box<dyn PartialReflect>

The type produced by using this seed.

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