Struct ReflectSerializer 

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

A general purpose serializer for reflected types.

This is the serializer counterpart to ReflectDeserializer.

See TypedReflectSerializer for a serializer that serializes a known type.

Output

This serializer will output 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.

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 = ReflectSerializer::new(&input, &registry);
let output = ron::to_string(&reflect_serializer).unwrap();

assert_eq!(output, r#"{"my_crate::MyStruct":(value:123)}"#);

Implementations

impl<'a> ReflectSerializer<'a>

pub fn new( value: &'a (dyn PartialReflect + 'static), registry: &'a TypeRegistry, ) -> ReflectSerializer<'a>

Creates a serializer with no processor.

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

impl<'a, P> ReflectSerializer<'a, P>

where P: ReflectSerializerProcessor,

pub fn with_processor( value: &'a (dyn PartialReflect + 'static), registry: &'a TypeRegistry, processor: &'a P, ) -> ReflectSerializer<'a, P>

Creates a serializer with a processor.

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

Trait Implementations

impl<P> Serialize for ReflectSerializer<'_, P>

where P: ReflectSerializerProcessor,

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

where S: Serializer,

Serialize this value into the given Serde serializer.