Trait bevy::prelude::Reflect

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 type_name(&self) -> &str

Returns the type name of the underlying type.

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>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

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>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.

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))

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 a Struct, then the value of each named field of value is applied to the corresponding named field of self. Fields which are not present in both structs are ignored.
If T is a TupleStruct or Tuple, then the value of each numbered field is applied to the corresponding numbered field of self. Fields which are not present in both values are ignored.
If T is an Enum, then the variant of self is updated to match the variant of value. The corresponding fields of that variant are applied from value onto self. Fields which are not present in both values are ignored.
If T is a List or Array, then each element of value is applied to the corresponding element of self. Up to self.len() items are applied, and excess elements in value are appended to self.
If T is a Map, then for each key in value, the associated value is applied to the value associated with the same key in self. Keys which are not present in self are inserted.
If T is none of these, then value is downcast to T, cloned, and assigned to self.

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 value is not of the same kind as T (e.g. if T is a List, while value is a Struct).
If T is any complex type and the corresponding fields or elements of self and value are not of the same type.
If T is a value type and self cannot be downcast to T

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<'_>

Returns an enumeration of “kinds” of type.

See ReflectRef.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

See ReflectMut.

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>

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>

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>

Returns a “partial equality” comparison result.

If the underlying type does not support equality testing, returns None.

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value.

Any value that is not an implementor of other Reflect subtraits (e.g. List, Map), will default to the format: "Reflect(type_name)", where type_name is the type name of the underlying type.

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

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,

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,

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,

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.