pub trait Reflect: Any + Send + Sync {
Show 18 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>;
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 Array
, List
,
Map
, Tuple
, TupleStruct
, Struct
, and Enum
subtraits.
When using #[derive(Reflect)]
on a struct, tuple struct or enum, the suitable subtrait for that
type (Struct
, TupleStruct
or Enum
) 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.
fn 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>
.
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 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.
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.
fn 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
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 anEnum
, then the variant ofself
isupdated
to match the variant ofvalue
. The corresponding fields of that variant are applied fromvalue
ontoself
. Fields which are not present in both values are ignored. - If
T
is aList
orArray
, 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
, 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
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
fn 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.
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 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
.
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, 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§
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) -> 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.
pub 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.
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 GetPath for dyn Reflect + 'static
impl GetPath for dyn Reflect + 'static
§fn path<'r, 'p>(
&'r self,
path: &'p str
) -> Result<&'r (dyn Reflect + 'static), ReflectPathError<'p>>
fn path<'r, 'p>(
&'r self,
path: &'p str
) -> Result<&'r (dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read more§fn path_mut<'r, 'p>(
&'r mut self,
path: &'p str
) -> Result<&'r mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn path_mut<'r, 'p>(
&'r mut self,
path: &'p str
) -> Result<&'r mut (dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read more§fn get_path<T, 'r, 'p>(
&'r self,
path: &'p str
) -> Result<&'r T, ReflectPathError<'p>>where
T: Reflect,
fn get_path<T, 'r, 'p>(
&'r self,
path: &'p str
) -> Result<&'r T, ReflectPathError<'p>>where
T: Reflect,
path
.§fn get_path_mut<T, 'r, 'p>(
&'r mut self,
path: &'p str
) -> Result<&'r mut T, ReflectPathError<'p>>where
T: Reflect,
fn get_path_mut<T, 'r, 'p>(
&'r mut self,
path: &'p str
) -> Result<&'r mut T, ReflectPathError<'p>>where
T: Reflect,
path
. Read more