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.

Examples found in repository

examples/reflection/serialization.rs (line 62)

fn serialize(type_registry: Res<AppTypeRegistry>) {
    let type_registry = type_registry.read();

    // a concrete value
    let value = Player {
        name: "BevyPlayerSerialize".to_string(),
        health: 80,
    };

    // By default, all derived `Reflect` types can be serialized using serde. No need to derive
    // Serialize!
    let serializer = ReflectSerializer::new(&value, &type_registry);
    let json = serde_json::to_string(&serializer).unwrap();
    info!(?json);
}

examples/reflection/reflection.rs (line 92)

fn setup(type_registry: Res<AppTypeRegistry>) {
    let mut value = Foo {
        a: 1,
        _ignored: NonReflectedValue { _a: 10 },
        nested: Bar { b: 8 },
    };

    // You can set field values like this. The type must match exactly or this will fail.
    *value.get_field_mut("a").unwrap() = 2usize;
    assert_eq!(value.a, 2);
    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);

    // You can also get the `&dyn PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_downcast_ref::<usize>().unwrap(), 2);

    // `DynamicStruct` also implements the `Struct` and `Reflect` traits.
    let mut patch = DynamicStruct::default();
    patch.insert("a", 4usize);

    // You can "apply" Reflect implementations on top of other Reflect implementations.
    // This will only set fields with the same name, and it will fail if the types don't match.
    // You can use this to "patch" your types with new values.
    value.apply(&patch);
    assert_eq!(value.a, 4);

    let type_registry = type_registry.read();
    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive
    // Serialize!
    let serializer = ReflectSerializer::new(&value, &type_registry);
    let ron_string =
        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
    info!("{}\n", ron_string);

    // Dynamic properties can be deserialized
    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();

    // Deserializing returns a `Box<dyn PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
    // like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
    // `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
    assert!(reflect_value.reflect_partial_eq(&value).unwrap());

    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
    // This means we can serialize and deserialize with a single `Reflect` derive!
    value.apply(&*reflect_value);
}

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.