Struct bevy_internal::reflect::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 std::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(std::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 + 'static)

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 + 'static)

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 + 'static)

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 + 'static)

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 copy of the value.

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

Performs copy-assignment from source.

impl<T> FromType<T> for ReflectFromPtr

where T: Reflect,

fn from_type() -> ReflectFromPtr