How to reflect TypeId wrapper with type registery?

[Rratic]

This is a part of question #17839

Rust TypeId works as an unique identifier so it's unstable and does not sypport reflect.

In my answer in the discussion however, if I'm right, it's a must to use TypeId.

Type AppTypeRegistry is actually a wrapper of TypeRegistryArc, which points to a TypeRegistry, which provides short_path_to_id and type_path_to_id, but aren't public.

So how can I define the way a TypeId wrapper seralizes and deserializes so that it inspects type registery and eventually works for scene saving and loading?

[MrGVSV]

Assuming the type represented by TypeId is registered, you might be able to use SerializeWithRegistry and its corresponding type data to fetch that type by the TypeId, retrieve its type path, and then serialize that path. Then just do the reverse with the deserializer counterparts.

And fwiw, eventually I do want to move away from TypeId being the registry key in order to better support dynamic/runtime/scripting types.

[Rratic]

Thanks.

Currently my code looks like:

use bevy::{
    prelude::*,
    reflect::{
        serde::{ReflectSerializeWithRegistry, SerializeWithRegistry},
        TypeRegistry,
    },
};
use serde::Serializer;
use std::any::TypeId;

#[derive(Reflect, Component, Clone)]
#[reflect(Component)]
#[reflect(SerializeWithRegistry)]
#[component(storage = "Table")]
pub struct IsObject(pub TypeId);

impl SerializeWithRegistry for IsObject {
    fn serialize<S>(&self, serializer: S, registry: &TypeRegistry) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let registeration = registry.get(self.0).unwrap();
        let info = registeration.type_info();
        let path = info.type_path();
        let state = serializer.serialize_str(path);
        state
    }
}

impl<'de> DeserializeWithRegistry<'de> for IsObject {
    fn deserialize<D>(deserializer: D, registry: &TypeRegistry) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct MyVisitor<'a> {
            registry: &'a TypeRegistry,
        }

        impl<'a, 'de> Visitor<'de> for MyVisitor<'a> {
            type Value = TypeId;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(formatter, "a type path")
            }

            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
                where
                    E: serde::de::Error, {
                let registeration = self.registry.get_with_type_path(v).unwrap();
                let id = registeration.type_id();
                Ok(id)
            }
        }

        deserializer
            .deserialize_str(MyVisitor { registry })
            .map(IsObject)
    }
}