Struct TypedReflectSerializer

pub struct TypedReflectSerializer<'a, P = ()> { /* private fields */ }

A serializer for reflected types whose type will be known during deserialization.

This is the serializer counterpart to TypedReflectDeserializer.

See ReflectSerializer for a serializer that serializes an unknown type.

Output

Since the type is expected to be known during deserialization, this serializer will not output any additional type information, such as the type path.

Instead, it will output just the serialized data.

If you want to override serialization for specific values, you can pass in a reference to a ReflectSerializerProcessor which will take priority over all other serialization 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 = MyStruct { value: 123 };

let reflect_serializer = TypedReflectSerializer::new(&input, &registry);
let output = ron::to_string(&reflect_serializer).unwrap();

assert_eq!(output, r#"(value:123)"#);

Implementations

impl<'a> TypedReflectSerializer<'a, ()>

pub fn new(value: &'a dyn PartialReflect, registry: &'a TypeRegistry) -> Self

Creates a serializer with no processor.

If you want to add custom logic for serializing certain values, use with_processor.

impl<'a, P> TypedReflectSerializer<'a, P>

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

Creates a serializer with a processor.

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

Trait Implementations

impl<P: ReflectSerializerProcessor> Serialize for TypedReflectSerializer<'_, P>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.