Struct ReflectFromPtr

pub struct ReflectFromPtr { /* private fields */ }

Reflect values are commonly used in situations where the actual types of values are not known at runtime. In such situations you might have access to a *const () pointer that you know implements Reflect, but have no way of turning it into a &dyn Reflect.

This is where ReflectFromPtr comes in, when creating a ReflectFromPtr for a given type T: Reflect. Internally, this saves a concrete function *const T -> const dyn Reflect which lets you create a trait object of Reflect from a pointer.

Example

use bevy_reflect::{TypeRegistry, Reflect, ReflectFromPtr};
use bevy_ptr::Ptr;
use core::ptr::NonNull;

#[derive(Reflect)]
struct Reflected(String);

let mut type_registry = TypeRegistry::default();
type_registry.register::<Reflected>();

let mut value = Reflected("Hello world!".to_string());
let value = Ptr::from(&value);

let reflect_data = type_registry.get(core::any::TypeId::of::<Reflected>()).unwrap();
let reflect_from_ptr = reflect_data.data::<ReflectFromPtr>().unwrap();
// SAFE: `value` is of type `Reflected`, which the `ReflectFromPtr` was created for
let value = unsafe { reflect_from_ptr.as_reflect(value) };

assert_eq!(value.downcast_ref::<Reflected>().unwrap().0, "Hello world!");

Implementations

impl ReflectFromPtr

pub fn type_id(&self) -> TypeId

Returns the TypeId that the ReflectFromPtr was constructed for.

pub unsafe fn as_reflect<'a>(&self, val: Ptr<'a>) -> &'a dyn Reflect

Convert Ptr into &dyn Reflect.

Safety

val must be a pointer to value of the type that the ReflectFromPtr was constructed for. This can be verified by checking that the type id returned by ReflectFromPtr::type_id is the expected one.

pub unsafe fn as_reflect_mut<'a>(&self, val: PtrMut<'a>) -> &'a mut dyn Reflect

Convert PtrMut into &mut dyn Reflect.

Safety

val must be a pointer to a value of the type that the ReflectFromPtr was constructed for This can be verified by checking that the type id returned by ReflectFromPtr::type_id is the expected one.

pub fn from_ptr(&self) -> unsafe fn(Ptr<'_>) -> &dyn Reflect

Get a function pointer to turn a Ptr into &dyn Reflect for the type this ReflectFromPtr was constructed for.

Safety

When calling the unsafe function returned by this method you must ensure that:

• The input Ptr points to the Reflect type this ReflectFromPtr was constructed for.

pub fn from_ptr_mut(&self) -> unsafe fn(PtrMut<'_>) -> &mut dyn Reflect

Get a function pointer to turn a PtrMut into &mut dyn Reflect for the type this ReflectFromPtr was constructed for.

Safety

When calling the unsafe function returned by this method you must ensure that:

• The input PtrMut points to the Reflect type this ReflectFromPtr was constructed for.

Trait Implementations

impl Clone for ReflectFromPtr

fn clone(&self) -> ReflectFromPtr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Reflect> FromType<T> for ReflectFromPtr

fn from_type() -> Self

Creates an instance of Self for type T.