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: WorldGuard<'_>, ) -> 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: WorldGuard<'_>) -> 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: Reflect>( value: T, allocator: &mut ReflectAllocator, ) -> ReflectReference

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_raw( type_id: TypeId, id: ReflectAllocationId, ) -> ReflectReference

Creates a raw reference to an existing allocation without checking the type ID. If the type id does not match you will get runtime errors

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: Resource>( world: WorldGuard<'_>, ) -> Result<Self, InteropError>

Create a new reference to resource

pub fn new_component_ref<T: Component>( entity: Entity, world: WorldGuard<'_>, ) -> Result<Self, InteropError>

Create a new reference to component

pub fn new_component_ref_by_id( entity: Entity, component_id: ComponentId, type_id: TypeId, ) -> Self

Create a new reference to component by id. If the type id is incorrect, you will get runtime errors when trying to access the value.

pub fn new_resource_ref_by_id( component_id: ComponentId, type_id: TypeId, ) -> Self

Create a new reference to resource by id. If the type id is incorrect, you will get runtime errors when trying to access the value.

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

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: Clone + PartialReflect>( &self, world: WorldGuard<'_>, ) -> Result<O, InteropError>

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

pub fn to_owned_value( &self, world: WorldGuard<'_>, ) -> 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: FnOnce(&dyn PartialReflect) -> O>( &self, world: WorldGuard<'_>, f: F, ) -> Result<O, InteropError>

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: FnOnce(&mut dyn PartialReflect) -> O>( &self, world: WorldGuard<'_>, f: F, ) -> Result<O, InteropError>

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: WorldGuard<'_>, ) -> Result<Option<TypeId>, InteropError>

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

pub fn element_type_id( &self, world: WorldGuard<'_>, ) -> 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: WorldGuard<'_>, ) -> 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: WorldGuard<'_>, ) -> 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: WorldGuard<'w>, ) -> Result<&'w dyn PartialReflect, 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: WorldGuard<'w>, ) -> Result<&'w mut dyn PartialReflect, 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 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

Formats the value using the given formatter.

impl DebugWithTypeInfo for ReflectReference

fn to_string_with_type_info( &self, f: &mut Formatter<'_>, type_info_provider: Option<&dyn GetTypeInfo>, ) -> Result

Format the value using the provided type info provider if available

impl Default for ReflectReference

fn default() -> Self

Returns the “default value” for a type.

impl DisplayWithTypeInfo for ReflectReference

fn display_with_type_info( &self, f: &mut Formatter<'_>, type_info_provider: Option<&dyn GetTypeInfo>, ) -> Result

Format the value using the provided type info provider if available

impl From<ReflectReference> for ScriptValue

fn from(value: ReflectReference) -> Self

Converts to this type from the input type.

impl FromReflect for ReflectReference

where ReflectReference: Any + Send + Sync,

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

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: WorldGuard<'_>, ) -> Result<Self, 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: WorldGuard<'_>, ) -> Result<ScriptValue, InteropError>

Convert this value into a ScriptValue.

fn into_script_inline_error(self, world: WorldGuard<'_>) -> 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: WorldGuard<'_>, ) -> Result<ScriptValue, InteropError>

Converts a value represented by a reference into a [crate::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 to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn try_apply(&mut self, value: &dyn PartialReflect) -> 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<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> 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>

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

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

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

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

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

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

Applies a reflected value to this value.

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

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

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 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<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

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

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

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

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