pub trait Reflect: Any + Send + Sync {
Show 16 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 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 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 debug(&self, f: &mut Formatter<'_>) -> Result<(), Error> { ... }
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.
Required Methods
fn 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.
Returns the value as a Box<dyn Any>
.
fn 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
.
fn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
Casts this type to a reflected value
fn 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
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 inself
are inserted. - 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 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
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.
Provided 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
impl dyn Reflect + 'static
impl dyn Reflect + 'static
pub 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)
.
pub 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)
.
pub fn represents<T>(&self) -> bool where
T: Reflect,
pub fn represents<T>(&self) -> bool where
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.
pub 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.
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.
pub 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
.
pub 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
impl<'a> AsMut<dyn Reflect + 'static> for ReflectMut<'a>
impl<'a> AsMut<dyn Reflect + 'static> for ReflectMut<'a>
impl<'a> AsRef<dyn Reflect + 'static> for ReflectMut<'a>
impl<'a> AsRef<dyn Reflect + 'static> for ReflectMut<'a>
impl GetPath for dyn Reflect + 'static
impl GetPath for dyn Reflect + 'static
fn 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
fn 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
fn 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
.
fn 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