Trait ReflectRemote 

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;
}

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,
}

Required Associated Types

type Remote

The remote type this type represents via reflection.

Required Methods

fn as_remote(&self) -> &Self::Remote

Converts a reference of this wrapper to a reference of its remote type.

fn as_remote_mut(&mut self) -> &mut Self::Remote

Converts a mutable reference of this wrapper to a mutable reference of its remote type.

fn into_remote(self) -> Self::Remote

Converts this wrapper into its remote type.

fn as_wrapper(remote: &Self::Remote) -> &Self

Converts a reference of the remote type to a reference of this wrapper.

fn as_wrapper_mut(remote: &mut Self::Remote) -> &mut Self

Converts a mutable reference of the remote type to a mutable reference of this wrapper.

fn into_wrapper(remote: Self::Remote) -> Self

Converts the remote type into this wrapper.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors