Struct ReflectReference

#[non_exhaustive]
pub struct ReflectReference {
    pub base: ReflectBaseType,
    pub reflect_path: ParsedPath,
}

A reference to an arbitrary reflected instance.

The reference can point to either the ECS, or to the allocator.

References are composed of two parts:

• The base kind, which specifies where the reference points to
• The path, which specifies how to access the value from the base.

Bindings defined on this type, apply to ALL references.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

base: ReflectBaseType

The base type and id of the value we want to access

reflect_path: ParsedPath

The path from the top level type to the actual value we want to access

Implementations

impl ReflectReference

pub fn variant_name( &self, world: WorldAccessGuard<'_>, ) -> Result<Option<String>, InteropError>

If this points to a variant of an enum, returns the name of the variant.

pub fn into_iter_infinite(self) -> ReflectRefIter

Creates a new infinite iterator. This iterator will keep returning the next element reference forever.

pub fn len( &self, world: WorldAccessGuard<'_>, ) -> Result<Option<usize>, InteropError>

If this is a reference to something with a length accessible via reflection, returns that length.

pub fn new_allocated<T>( value: T, allocator: &mut ReflectAllocator, ) -> ReflectReference

where T: Reflect,

Create a new reference to a value by allocating it.

You can retrieve the allocator from the world using WorldGuard::allocator. Make sure to drop the allocator write guard before doing anything with the reference to prevent deadlocks.

pub fn new_allocated_boxed_parial_reflect( value: Box<dyn PartialReflect>, allocator: &mut ReflectAllocator, ) -> Result<ReflectReference, InteropError>

Create a new reference to a value by allocating it.

Prefer using Self::new_allocated if you have a value that implements Reflect. Will fail if the value does not have represented type info with a specific type id.

pub fn new_allocated_boxed( value: Box<dyn Reflect>, allocator: &mut ReflectAllocator, ) -> ReflectReference

Create a new reference to a value by allocating it.

pub fn new_resource_ref<T>( world: WorldAccessGuard<'_>, ) -> Result<ReflectReference, InteropError>

where T: Resource,

Create a new reference to resource

pub fn new_component_ref<T>( entity: Entity, world: WorldAccessGuard<'_>, ) -> Result<ReflectReference, InteropError>

where T: Component,

Create a new reference to component

pub fn index_path<T>(&mut self, index: T)

where T: Into<ParsedPath>,

Indexes into the reflect path inside this reference. You can use [Self::reflect] and Self::reflect_mut to get the actual value.

pub fn downcast<O>( &self, world: WorldAccessGuard<'_>, ) -> Result<O, InteropError>

where O: Clone + PartialReflect,

Tries to downcast to the specified type and cloning the value if successful.

pub fn to_owned_value( &self, world: WorldAccessGuard<'_>, ) -> Result<Box<dyn PartialReflect>, InteropError>

Attempts to create a Box<dyn PartialReflect> from the reference. This is possible using a few strategies:

• If the reference is to a world, a [WorldCallbackAccess] is created and boxed
• If the reference is to an allocation with no reflection path and references to it, the value is taken as is.
• If the reference has a bevy::reflect::ReflectFromReflect type data associated with it, the value is cloned using that impl.
• If all above fails, bevy::reflect::PartialReflect::clone_value is used to clone the value.

pub fn with_reflect<O, F>( &self, world: WorldAccessGuard<'_>, f: F, ) -> Result<O, InteropError>

where F: FnOnce(&(dyn PartialReflect + 'static)) -> O,

The way to access the value of the reference, that is the pointed-to value. This method is safe to use as it ensures no-one else has aliasing access to the value at the same time.

pub fn with_reflect_mut<O, F>( &self, world: WorldAccessGuard<'_>, f: F, ) -> Result<O, InteropError>

where F: FnOnce(&mut (dyn PartialReflect + 'static)) -> O,

The way to access the value of the reference, that is the pointed-to value. This method is safe to use as it ensures no-one else has aliasing access to the value at the same time.

pub fn tail_type_id( &self, world: WorldAccessGuard<'_>, ) -> Result<Option<TypeId>, InteropError>

Retrieves the type id of the value the reference points to.

pub fn element_type_id( &self, world: WorldAccessGuard<'_>, ) -> Result<Option<TypeId>, InteropError>

Retrieves the type id of the elements in the value the reference points to.

pub fn key_type_id( &self, world: WorldAccessGuard<'_>, ) -> Result<Option<TypeId>, InteropError>

Retrieves the type id of the keys in the value the reference points to.

pub fn type_id_of( &self, source: TypeIdSource, world: WorldAccessGuard<'_>, ) -> Result<Option<TypeId>, InteropError>

Retrieves the type id of the value the reference points to based on the given source.

pub unsafe fn reflect_unsafe<'w>( &self, world: WorldAccessGuard<'w>, ) -> Result<&'w (dyn PartialReflect + 'static), InteropError>

Retrieves a reference to the underlying dyn PartialReflect type valid for the ’w lifetime of the world cell

Safety

• The caller must ensure the cell has permission to access the underlying value
• The caller must ensure no aliasing references to the same value exist at all at the same time

To do this safely you need to use [WorldAccessGuard::claim_read_access] or [WorldAccessGuard::claim_global_access] to ensure nobody else is currently accessing the value.

pub unsafe fn reflect_mut_unsafe<'w>( &self, world: WorldAccessGuard<'w>, ) -> Result<&'w mut (dyn PartialReflect + 'static), InteropError>

Retrieves mutable reference to the underlying dyn PartialReflect type valid for the ’w lifetime of the world cell

Safety

• The caller must ensure the cell has permission to access the underlying value
• The caller must ensure no other references to the same value exist at all at the same time (even if you have the correct access)

To do this safely you need to use [WorldAccessGuard::claim_write_access] or [WorldAccessGuard::claim_global_access] to ensure nobody else is currently accessing the value.

Trait Implementations

impl ArgMeta for ReflectReference

fn default_value() -> Option<ScriptValue>

The default value for the argument. Used when the argument is not provided.

impl AsRef<ReflectReference> for LuaReflectReference

fn as_ref(&self) -> &ReflectReference

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<ReflectReference> for RhaiReflectReference

fn as_ref(&self) -> &ReflectReference

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ReflectReference

fn clone(&self) -> ReflectReference

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReflectReference

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for ReflectReference

fn default() -> ReflectReference

Returns the “default value” for a type.

impl DisplayWithWorld for ReflectReference

fn display_with_world(&self, world: WorldAccessGuard<'_>) -> String

Display the shallowest representation of the type using world access. For references this is the type path and the type of the value they are pointing to.

fn display_value_with_world(&self, world: WorldAccessGuard<'_>) -> String

Display the most literal representation of the type using world access. I.e. for references this would be the pointed to value itself.

fn display_without_world(&self) -> String

Warning

impl From<LuaReflectReference> for ReflectReference

fn from(value: LuaReflectReference) -> ReflectReference

Converts to this type from the input type.

impl From<ReflectReference> for LuaReflectReference

fn from(value: ReflectReference) -> LuaReflectReference

Converts to this type from the input type.

impl From<ReflectReference> for RhaiReflectReference

fn from(value: ReflectReference) -> RhaiReflectReference

Converts to this type from the input type.

impl From<ReflectReference> for ScriptValue

fn from(value: ReflectReference) -> ScriptValue

Converts to this type from the input type.

impl From<RhaiReflectReference> for ReflectReference

fn from(value: RhaiReflectReference) -> ReflectReference

Converts to this type from the input type.

impl FromReflect for ReflectReference

where ReflectReference: Any + Send + Sync,

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<ReflectReference>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl FromScript for ReflectReference

type This<'w> = ReflectReference

The type that is constructed from the script value.

fn from_script( value: ScriptValue, _world: WorldAccessGuard<'_>, ) -> Result<ReflectReference, InteropError>

Construct a value of type T from a ScriptValue.

impl GetTypeDependencies for ReflectReference

type Underlying = ReflectReference

In the majority of the implementations, this will be Self However some types might be facades for other types, in which case this will be the underlying type

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers the type dependencies of the implementing type with the given TypeRegistry.

impl GetTypeRegistration for ReflectReference

where ReflectReference: Any + Send + Sync,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoScript for ReflectReference

fn into_script( self, _world: WorldAccessGuard<'_>, ) -> Result<ScriptValue, InteropError>

Convert this value into a ScriptValue.

fn into_script_inline_error(self, world: WorldAccessGuard<'_>) -> ScriptValue

where Self: Sized,

Convert this value into a ScriptValue, returning an error as a ScriptValue if an error occurs.

impl IntoScriptRef for ReflectReference

fn into_script_ref( self_: ReflectReference, world: WorldAccessGuard<'_>, ) -> Result<ScriptValue, InteropError>

Converts a value represented by a reference into a [crate::bindings::function::ScriptValue].

impl PartialEq for ReflectReference

fn eq(&self, other: &ReflectReference) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialReflect for ReflectReference

where ReflectReference: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<ReflectReference>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<ReflectReference>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<ReflectReference>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq( &self, _value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for ReflectReference

where ReflectReference: Any + Send + Sync,

fn into_any(self: Box<ReflectReference>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<ReflectReference>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl TypePath for ReflectReference

where ReflectReference: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for ReflectReference

where ReflectReference: Any + Send + Sync,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl TypedThrough for ReflectReference

fn through_type_info() -> ThroughTypeInfo

Get the ThroughTypeInfo for the type.

impl Eq for ReflectReference

impl StructuralPartialEq for ReflectReference