Trait ReflectRemote

Source

pub trait ReflectRemote: Reflect {
    type Remote;

    // Required methods
    fn as_remote(&self) -> &Self::Remote;
    fn as_remote_mut(&mut self) -> &mut Self::Remote;
    fn into_remote(self) -> Self::Remote;
    fn as_wrapper(remote: &Self::Remote) -> &Self;
    fn as_wrapper_mut(remote: &mut Self::Remote) -> &mut Self;
    fn into_wrapper(remote: Self::Remote) -> Self;
}

Expand description

Marks a type as a reflectable wrapper for a remote type.

This allows types from external libraries (remote types) to be included in reflection.

§Safety

It is highly recommended to avoid implementing this trait manually and instead use the #[reflect_remote] attribute macro. This is because the trait tends to rely on transmute, which is very unsafe.

The macro will ensure that the following safety requirements are met:

Self is a single-field tuple struct (i.e. a newtype) containing the remote type.
Self is #[repr(transparent)] over the remote type.

Additionally, the macro will automatically generate Reflect and FromReflect implementations, along with compile-time assertions to validate that the safety requirements have been met.

§Example

use bevy_reflect_derive::{reflect_remote, Reflect};

mod some_lib {
  pub struct TheirType {
    pub value: u32
  }
}

#[reflect_remote(some_lib::TheirType)]
struct MyType {
  pub value: u32
}

#[derive(Reflect)]
struct MyStruct {
  #[reflect(remote = MyType)]
  data: some_lib::TheirType,
}