Struct bevy_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 = unsafe { Ptr::new(NonNull::from(&mut value).cast()) };

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_ptr(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_ptr<'a>(&self, val: Ptr<'a>) -> &'a 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_ptr_mut<'a>(
    &self,
    val: PtrMut<'a>
) -> &'a 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.

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: Reflect> FromType<T> for ReflectFromPtr

fn from_type() -> Self