Trait bevy_internal::reflect::Reflect
source · [−]pub unsafe trait Reflect: Any + Send + Sync {
fn type_name(&self) -> &str;
fn any(&self) -> &(dyn Any + 'static);
fn any_mut(&mut self) -> &mut (dyn Any + '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 clone_value(&self) -> Box<dyn Reflect + 'static, Global>;
fn reflect_hash(&self) -> Option<u64>;
fn reflect_partial_eq(
&self,
_value: &(dyn Reflect + 'static)
) -> Option<bool>;
fn serializable(&self) -> Option<Serializable<'_>>;
}
Expand description
A reflected Rust type.
Methods for working with particular kinds of Rust type are available using the List
, Map
,
Struct
, TupleStruct
, and Tuple
subtraits.
When using #[derive(Reflect)]
with a struct or tuple struct, the suitable subtrait for that
type (Struct
or TupleStruct
) is derived automatically.
Safety
Implementors must ensure that Reflect::any
and Reflect::any_mut
both return the self
value passed in. If this is not done, Reflect::downcast
will be UB (and also just logically broken).
Required Methods
Returns the value as a &mut dyn Any
.
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
T
is aStruct
, then the value of each named field ofvalue
is applied to the corresponding named field ofself
. Fields which are not present in both structs are ignored. - If
T
is aTupleStruct
orTuple
, 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
T
is aList
, then each element ofvalue
is applied to the corresponding element ofself
. Up toself.len()
items are applied, and excess elements invalue
are appended toself
. - If
T
is 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 in both maps are ignored. - If
T
is none of these, thenvalue
is downcast toT
, cloned, and assigned toself
.
Note that Reflect
must be implemented manually for List
s and
Map
s in order to achieve the correct semantics, as derived
implementations will have the semantics for Struct
, TupleStruct
or none of the above depending on the kind of type. For lists, use the
list_apply
helper function when implementing this method.
Panics
Derived implementations of this method will panic:
- If the type of
value
is not of the same kind asT
(e.g. ifT
is aList
, whilevalue
is aStruct
). - If
T
is any complex type and the corresponding fields or elements ofself
andvalue
are not of the same type. - If
T
is a value type andself
cannot be downcast toT
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.
fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
Returns an enumeration of “kinds” of type.
See ReflectRef
.
fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
Returns a mutable enumeration of “kinds” of type.
See ReflectMut
.
fn 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 or struct tuple, the value is
cloned via Struct::clone_dynamic
(resp.
TupleStruct::clone_dynamic
). Implementors of other Reflect
subtraits (e.g. List
, Map
) should use those subtraits’
respective clone_dynamic
methods.
fn 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
.
fn 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
.
fn 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
sourceimpl 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 is<T>(&self) -> bool where
T: Reflect,
pub fn is<T>(&self) -> bool where
T: Reflect,
Returns true
if the underlying value is of type T
, or false
otherwise.
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
sourceimpl<'a> AsMut<dyn Reflect + 'static> for ReflectMut<'a>
impl<'a> AsMut<dyn Reflect + 'static> for ReflectMut<'a>
sourceimpl<'a> AsRef<dyn Reflect + 'static> for ReflectMut<'a>
impl<'a> AsRef<dyn Reflect + 'static> for ReflectMut<'a>
sourceimpl GetPath for dyn Reflect + 'static
impl GetPath for dyn Reflect + 'static
sourcefn path(
&'r self,
path: &'p str
) -> Result<&'r (dyn Reflect + 'static), ReflectPathError<'p>>
fn path(
&'r self,
path: &'p str
) -> Result<&'r (dyn Reflect + 'static), ReflectPathError<'p>>
Returns a reference to the value specified by path
. Read more
sourcefn path_mut(
&'r mut self,
path: &'p str
) -> Result<&'r mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn path_mut(
&'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
sourcefn get_path<T>(&'r self, path: &'p str) -> Result<&'r T, ReflectPathError<'p>> where
T: Reflect,
fn get_path<T>(&'r self, path: &'p str) -> Result<&'r T, ReflectPathError<'p>> where
T: Reflect,
Returns a statically typed reference to the value specified by path
.
sourcefn get_path_mut<T>(
&'r mut self,
path: &'p str
) -> Result<&'r mut T, ReflectPathError<'p>> where
T: Reflect,
fn get_path_mut<T>(
&'r mut self,
path: &'p str
) -> Result<&'r mut T, ReflectPathError<'p>> where
T: Reflect,
Returns a statically typed mutable reference to the value specified by
path
. Read more