Trait bevy_internal::reflect::Reflect
source · pub trait Reflect: Any + Send + Sync {
Show 18 methods
// Required methods
fn type_name(&self) -> &str;
fn get_type_info(&self) -> &'static TypeInfo;
fn into_any(self: Box<Self, Global>) -> Box<dyn Any + 'static, Global>;
fn as_any(&self) -> &(dyn Any + 'static);
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static);
fn into_reflect(
self: Box<Self, Global>
) -> Box<dyn Reflect + 'static, Global>;
fn as_reflect(&self) -> &(dyn Reflect + 'static);
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static);
fn apply(&mut self, value: &(dyn Reflect + 'static));
fn set(
&mut self,
value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>;
fn reflect_ref(&self) -> ReflectRef<'_>;
fn reflect_mut(&mut self) -> ReflectMut<'_>;
fn reflect_owned(self: Box<Self, Global>) -> ReflectOwned;
fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>;
// Provided methods
fn reflect_hash(&self) -> Option<u64> { ... }
fn reflect_partial_eq(
&self,
_value: &(dyn Reflect + 'static)
) -> Option<bool> { ... }
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error> { ... }
fn serializable(&self) -> Option<Serializable<'_>> { ... }
}Expand description
The core trait of bevy_reflect, used for accessing and modifying data dynamically.
It’s recommended to use the derive macro rather than manually implementing this trait.
Doing so will automatically implement many other useful traits for reflection,
including one of the appropriate subtraits: Struct, TupleStruct or Enum.
See the crate-level documentation to see how this trait and its subtraits can be used.
Required Methods§
sourcefn get_type_info(&self) -> &'static TypeInfo
fn get_type_info(&self) -> &'static TypeInfo
Returns the TypeInfo of the underlying type.
This method is great if you have an instance of a type or a dyn Reflect,
and want to access its TypeInfo. However, if this method is to be called
frequently, consider using TypeRegistry::get_type_info as it can be more
performant for such use cases.
sourcefn into_any(self: Box<Self, Global>) -> Box<dyn Any + 'static, Global>
fn into_any(self: Box<Self, Global>) -> Box<dyn Any + 'static, Global>
Returns the value as a Box<dyn Any>.
sourcefn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Returns the value as a &mut dyn Any.
sourcefn into_reflect(self: Box<Self, Global>) -> Box<dyn Reflect + 'static, Global>
fn into_reflect(self: Box<Self, Global>) -> Box<dyn Reflect + 'static, Global>
Casts this type to a boxed reflected value.
sourcefn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
Casts this type to a reflected value.
sourcefn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
Casts this type to a mutable reflected value.
sourcefn apply(&mut self, value: &(dyn Reflect + 'static))
fn apply(&mut self, value: &(dyn Reflect + 'static))
Applies a reflected value to this value.
If a type implements a subtrait of Reflect, then the semantics of this
method are as follows:
- If
Tis aStruct, then the value of each named field ofvalueis applied to the corresponding named field ofself. Fields which are not present in both structs are ignored. - If
Tis aTupleStructorTuple, then the value of each numbered field is applied to the corresponding numbered field ofself.Fields which are not present in both values are ignored. - If
Tis anEnum, then the variant ofselfisupdatedto match the variant ofvalue. The corresponding fields of that variant are applied fromvalueontoself. Fields which are not present in both values are ignored. - If
Tis aListorArray, then each element ofvalueis applied to the corresponding element ofself. Up toself.len()items are applied, and excess elements invalueare appended toself. - If
Tis aMap, then for each key invalue, the associated value is applied to the value associated with the same key inself. Keys which are not present inselfare inserted. - If
Tis none of these, thenvalueis downcast toT, cloned, and assigned toself.
Note that Reflect must be implemented manually for Lists and
Maps in order to achieve the correct semantics, as derived
implementations will have the semantics for Struct, TupleStruct, Enum
or none of the above depending on the kind of type. For lists and maps, use the
list_apply and map_apply helper functions when implementing this method.
Panics
Derived implementations of this method will panic:
- If the type of
valueis not of the same kind asT(e.g. ifTis aList, whilevalueis aStruct). - If
Tis any complex type and the corresponding fields or elements ofselfandvalueare not of the same type. - If
Tis a value type andselfcannot be downcast toT
sourcefn set(
&mut self,
value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>
fn set( &mut self, value: Box<dyn Reflect + 'static, Global> ) -> Result<(), Box<dyn Reflect + 'static, Global>>
Performs a type-checked assignment of a reflected value to this value.
If value does not contain a value of type T, returns an Err
containing the trait object.
sourcefn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
Returns an enumeration of “kinds” of type.
See ReflectRef.
sourcefn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
Returns a mutable enumeration of “kinds” of type.
See ReflectMut.
sourcefn reflect_owned(self: Box<Self, Global>) -> ReflectOwned
fn reflect_owned(self: Box<Self, Global>) -> ReflectOwned
Returns an owned enumeration of “kinds” of type.
See ReflectOwned.
sourcefn clone_value(&self) -> Box<dyn Reflect + 'static, Global>
fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>
Clones the value as a Reflect trait object.
When deriving Reflect for a struct, tuple struct or enum, the value is
cloned via Struct::clone_dynamic, TupleStruct::clone_dynamic,
or Enum::clone_dynamic, respectively.
Implementors of other Reflect subtraits (e.g. List, Map) should
use those subtraits’ respective clone_dynamic methods.
Provided Methods§
sourcefn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
Returns a hash of the value (which includes the type).
If the underlying type does not support hashing, returns None.
sourcefn reflect_partial_eq(&self, _value: &(dyn Reflect + 'static)) -> Option<bool>
fn reflect_partial_eq(&self, _value: &(dyn Reflect + 'static)) -> Option<bool>
Returns a “partial equality” comparison result.
If the underlying type does not support equality testing, returns None.
sourcefn serializable(&self) -> Option<Serializable<'_>>
fn serializable(&self) -> Option<Serializable<'_>>
Returns a serializable version of the value.
If the underlying type does not support serialization, returns None.
Implementations§
source§impl dyn Reflect + 'static
impl dyn Reflect + 'static
sourcepub fn downcast<T>(
self: Box<dyn Reflect + 'static, Global>
) -> Result<Box<T, Global>, Box<dyn Reflect + 'static, Global>>where
T: Reflect,
pub fn downcast<T>( self: Box<dyn Reflect + 'static, Global> ) -> Result<Box<T, Global>, Box<dyn Reflect + 'static, Global>>where T: Reflect,
Downcasts the value to type T, consuming the trait object.
If the underlying value is not of type T, returns Err(self).
sourcepub fn take<T>(
self: Box<dyn Reflect + 'static, Global>
) -> Result<T, Box<dyn Reflect + 'static, Global>>where
T: Reflect,
pub fn take<T>( self: Box<dyn Reflect + 'static, Global> ) -> Result<T, Box<dyn Reflect + 'static, Global>>where T: Reflect,
Downcasts the value to type T, unboxing and consuming the trait object.
If the underlying value is not of type T, returns Err(self).
sourcepub fn represents<T>(&self) -> boolwhere
T: Reflect,
pub fn represents<T>(&self) -> boolwhere T: Reflect,
Returns true if the underlying value represents a value of type T, or false
otherwise.
Read is for more information on underlying values and represented types.
sourcepub fn is<T>(&self) -> boolwhere
T: Reflect,
pub fn is<T>(&self) -> boolwhere T: Reflect,
Returns true if the underlying value is of type T, or false
otherwise.
The underlying value is the concrete type that is stored in this dyn object;
it can be downcasted to. In the case that this underlying value “represents”
a different type, like the Dynamic*** types do, you can call represents
to determine what type they represent. Represented types cannot be downcasted
to, but you can use FromReflect to create a value of the represented type from them.
sourcepub fn downcast_ref<T>(&self) -> Option<&T>where
T: Reflect,
pub fn downcast_ref<T>(&self) -> Option<&T>where T: Reflect,
Downcasts the value to type T by reference.
If the underlying value is not of type T, returns None.
sourcepub fn downcast_mut<T>(&mut self) -> Option<&mut T>where
T: Reflect,
pub fn downcast_mut<T>(&mut self) -> Option<&mut T>where T: Reflect,
Downcasts the value to type T by mutable reference.
If the underlying value is not of type T, returns None.
Trait Implementations§
source§impl GetPath for dyn Reflect + 'static
impl GetPath for dyn Reflect + 'static
source§fn reflect_path<'r, 'p>(
&'r self,
path: &'p str
) -> Result<&'r (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path<'r, 'p>( &'r self, path: &'p str ) -> Result<&'r (dyn Reflect + 'static), ReflectPathError<'p>>
Returns a reference to the value specified by
path. Read moresource§fn reflect_path_mut<'r, 'p>(
&'r mut self,
path: &'p str
) -> Result<&'r mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'r, 'p>( &'r mut self, path: &'p str ) -> Result<&'r mut (dyn Reflect + 'static), ReflectPathError<'p>>
Returns a mutable reference to the value specified by
path. Read more