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 *mut T -> *mut dyn Reflect which lets you create a trait object of Reflect from a pointer.

Example

use bevy_reflect::{TypeRegistry, Reflect, ReflectFromPtr};
use core::any::Any;

#[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: &dyn Any = &value;

let reflect_data = type_registry.get(core::any::TypeId::of::<Reflected>()).unwrap();
let reflect_from_ptr = reflect_data.data::<ReflectFromPtr>().unwrap();
let value = reflect_from_ptr.as_reflect(value).unwrap();

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 fn raw_pointer_cast(&self) -> fn(*mut ()) -> *mut dyn Reflect

Returns the underlying function to cast from an arbitrary pointer to a [dyn Reflect] pointer.

This function effectively just adds the vtable pointer for Reflect for the type this ReflectFromPtr was constructed for, to whatever pointer you pass in. This function does no validation or manipulation - it just does a pointer cast.

The returned function is technically safe. We simply manipulate some pointers. However, using the result of this function requires the normal safety requirements. In particular, you must ensure that the original pointer actually pointed to a value of the type that this ReflectFromPtr was constructed for. This can be verified by checking that the type ID returned by ReflectFromPtr::type_id matches the original pointer’s runtime type ID. Note: It is not sufficient that you got this ReflectFromPtr from the type registry for type ID A. It is possible for someone to overwrite the ReflectFromPtr type data with that of a different type. Therefore, to ensure soundness, you must check ReflectFromPtr::type_id.

If you need to call this function for a *const (), you may simple use cast_mut for the input and cast_const for the output.

pub fn as_reflect<'a>( &self, any: &'a (dyn Any + 'static), ) -> Option<&'a (dyn Reflect + 'static)>

Converts a [&dyn Any] into a [&dyn Reflect] if the type matches the type used to construct this ReflectFromPtr.

pub fn as_reflect_mut<'a>( &self, any: &'a mut (dyn Any + 'static), ) -> Option<&'a mut (dyn Reflect + 'static)>

Converts a [&mut dyn Any] into a [&mut dyn Reflect] if the type matches the type used to construct this ReflectFromPtr.

pub fn box_as_reflect( &self, any: Box<dyn Any>, ) -> Result<Box<dyn Reflect>, Box<dyn Any>>

Converts a Box<dyn Any> into a Box<dyn Reflect> if the type matches the type used to construct this ReflectFromPtr.

If the type does not match Self::type_id, returns an Err holding any.

pub fn arc_as_reflect( &self, any: Arc<dyn Any>, ) -> Result<Arc<dyn Reflect>, Arc<dyn Any>>

Converts a Arc<dyn Any> into a Arc<dyn Reflect> if the type matches the type used to construct this ReflectFromPtr.

If the type does not match Self::type_id, returns an Err holding any.

pub unsafe fn ptr_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 ptr_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.

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> CreateTypeData<T> for ReflectFromPtr

where T: Reflect,

fn create_type_data(_input: ()) -> ReflectFromPtr

Create this type data using the given input.

fn insert_dependencies(type_registration: &mut TypeRegistration)

Inserts TypeData dependencies of this TypeData. This is especially useful for trait TypeData that has a supertrait (ex: A: B). When the TypeData for A is inserted, the B TypeData will also be inserted.