logo

Trait bevy::reflect::Reflect

[−]
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>ⓘNotable traits for Box<F, A>impl<F, A> Future for Box<F, A> where
    F: Future + Unpin + ?Sized,
    A: Allocator + 'static,     type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
    I: Iterator + ?Sized,
    A: Allocator,     type Item = <I as Iterator>::Item;;
    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 type name of the underlying type.

Returns the value as a &dyn Any.

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 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 both maps are ignored.
  • 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, 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 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

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.

Returns an enumeration of “kinds” of type.

See ReflectRef.

Returns a mutable enumeration of “kinds” of type.

See ReflectMut.

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.

Returns a hash of the value (which includes the type).

If the underlying type does not support hashing, returns None.

Returns a “partial equality” comparison result.

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

Returns a serializable version of the value.

If the underlying type does not support serialization, returns None.

Implementations

Downcasts the value to type T, consuming the trait object.

If the underlying value is not of type T, returns Err(self).

Downcasts the value to type T, unboxing and consuming the trait object.

If the underlying value is not of type T, returns Err(self).

Returns true if the underlying value is of type T, or false otherwise.

Downcasts the value to type T by reference.

If the underlying value is not of type T, returns None.

Downcasts the value to type T by mutable reference.

If the underlying value is not of type T, returns None.

Trait Implementations

Converts this type into a mutable reference of the (usually inferred) input type.

Converts this type into a shared reference of the (usually inferred) input type.

Formats the value using the given formatter. Read more

Returns a reference to the value specified by path. Read more

Returns a mutable reference to the value specified by path. Read more

Returns a statically typed reference to the value specified by path.

Returns a statically typed mutable reference to the value specified by path. Read more

Implementations on Foreign Types

Implementors