Trait bevy::reflect::Reflect

[−]

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 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 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 a List, 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 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 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>

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

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.