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>;
    fn reflect_hash(&self) -> Option<u64>;
    fn reflect_partial_eq(
        &self, 
        _value: &(dyn Reflect + 'static)
    ) -> Option<bool>;
    fn serializable(&self) -> Option<Serializable<'_>>;
}

A reflected rust type.

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

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>

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type) if hashing is supported. Otherwise None will be returned.

fn reflect_partial_eq(&self, _value: &(dyn Reflect + 'static)) -> Option<bool>

Returns a “partial equal” comparison result if comparison is supported. Otherwise None will be returned.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable value, if serialization is supported. Otherwise None will be returned.

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, 

pub fn take<T>(
    self: Box<dyn Reflect + 'static, Global>
) -> Result<T, Box<dyn Reflect + 'static, Global>> where
    T: Reflect, 

pub fn is<T>(&self) -> bool where
    T: Reflect, 

pub fn downcast_ref<T>(&self) -> Option<&T> where
    T: Reflect, 

pub fn downcast_mut<T>(&mut self) -> Option<&mut T> where
    T: Reflect, 

Trait Implementations

impl<'a> AsMut<dyn Reflect + 'static> for ReflectMut<'a>

pub fn as_mut(&mut self) -> &mut (dyn Reflect + 'static)

Performs the conversion.

impl<'a> AsRef<dyn Reflect + 'static> for ReflectMut<'a>

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

Performs the conversion.

impl Debug for dyn Reflect + 'static

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

Formats the value using the given formatter.

impl GetPath for dyn Reflect + 'static

pub fn path(
    &'r self,
    path: &'p str
) -> Result<&'r (dyn Reflect + 'static), ReflectPathError<'p>>

pub fn path_mut(
    &'r mut self,
    path: &'p str
) -> Result<&'r mut (dyn Reflect + 'static), ReflectPathError<'p>>

fn get_path<T>(&'r self, path: &'p str) -> Result<&'r 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, 

Implementations on Foreign Types

impl Reflect for u64

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for u32

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E, F, G, H, I, J, K> Reflect for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect,
    J: Reflect,
    K: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C> Reflect for (A, B, C) where
    A: Reflect,
    B: Reflect,
    C: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E, F, G, H, I, J> Reflect for (A, B, C, D, E, F, G, H, I, J) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect,
    J: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<K, V> Reflect for HashMap<K, V, RandomState> where
    K: Reflect + Eq + Hash,
    V: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for f64

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for ()

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for usize

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for u16

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for u8

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<T> Reflect for Option<T> where
    T: 'static + Serialize + Clone + for<'de> Deserialize<'de> + Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for i16

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E> Reflect for (A, B, C, D, E) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B> Reflect for (A, B) where
    A: Reflect,
    B: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D> Reflect for (A, B, C, D) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for f32

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for bool

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for i8

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E, F, G, H, I, J, K, L> Reflect for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect,
    J: Reflect,
    K: Reflect,
    L: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for isize

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E, F, G, H> Reflect for (A, B, C, D, E, F, G, H) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<T> Reflect for Range<T> where
    T: 'static + Serialize + Clone + for<'de> Deserialize<'de> + Send + Sync, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for u128

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<T> Reflect for Vec<T, Global> where
    T: FromReflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A> Reflect for (A,) where
    A: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<T> Reflect for SmallVec<T> where
    T: 'static + Array + Send + Sync,
    <T as Array>::Item: FromReflect,
    <T as Array>::Item: Clone, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E, F> Reflect for (A, B, C, D, E, F) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E, F, G> Reflect for (A, B, C, D, E, F, G) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for i128

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<A, B, C, D, E, F, G, H, I> Reflect for (A, B, C, D, E, F, G, H, I) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl<T> Reflect for HashSet<T, RandomState> where
    T: 'static + Serialize + Hash + Eq + Clone + for<'de> Deserialize<'de> + Send + Sync, 

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for i64

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for i32

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for Cow<'static, str>

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

impl Reflect for String

pub fn type_name(&self) -> &str

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

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn reflect_ref(&self) -> ReflectRef<'_>

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

pub fn reflect_hash(&self) -> Option<u64>

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

pub fn serializable(&self) -> Option<Serializable<'_>>

Implementors

impl Reflect for HandleId

impl Reflect for AlphaMode

impl Reflect for DepthCalculation

impl Reflect for ScalingMode

impl Reflect for WindowOrigin

impl Reflect for Color

impl Reflect for HorizontalAlign

impl Reflect for VerticalAlign

impl Reflect for AlignContent

impl Reflect for AlignItems

impl Reflect for AlignSelf

impl Reflect for Direction

impl Reflect for Display

impl Reflect for FlexDirection

impl Reflect for FlexWrap

impl Reflect for FocusPolicy

impl Reflect for Interaction

impl Reflect for JustifyContent

impl Reflect for Overflow

impl Reflect for PositionType

impl Reflect for Val

impl Reflect for ImageMode

impl Reflect for AssetPathId

impl Reflect for LabelId

impl Reflect for SourcePathId

impl Reflect for Name

impl Reflect for Stopwatch

impl Reflect for Timer

impl Reflect for Entity

impl Reflect for Mat4

impl Reflect for Vec3

impl Reflect for IVec2

impl Reflect for IVec3

impl Reflect for IVec4

impl Reflect for Mat3

impl Reflect for Quat

impl Reflect for UVec2

impl Reflect for UVec3

impl Reflect for UVec4

impl Reflect for Vec2

impl Reflect for Vec4

impl Reflect for CubemapVisibleEntities

impl Reflect for DirectionalLight

impl Reflect for PointLight

impl Reflect for Wireframe

impl Reflect for Camera

impl Reflect for OrthographicProjection

impl Reflect for PerspectiveProjection

impl Reflect for Aabb

impl Reflect for CubemapFrusta

impl Reflect for Frustum

impl Reflect for ComputedVisibility

impl Reflect for RenderLayers

impl Reflect for Visibility

impl Reflect for VisibleEntities

impl Reflect for bevy::sprite::Rect

impl Reflect for Sprite

impl Reflect for TextureAtlasSprite

impl Reflect for Text2dSize

impl Reflect for Text

impl Reflect for TextAlignment

impl Reflect for TextSection

impl Reflect for TextStyle

impl Reflect for Children

impl Reflect for GlobalTransform

impl Reflect for Parent

impl Reflect for PreviousParent

impl Reflect for Transform

impl Reflect for CalculatedClip

impl Reflect for CalculatedSize

impl Reflect for Node

impl Reflect for Style

impl Reflect for UiColor

impl Reflect for UiImage

impl Reflect for Button

impl Reflect for Duration

impl Reflect for DynamicList

impl Reflect for DynamicMap

impl Reflect for DynamicStruct

impl Reflect for DynamicTuple

impl Reflect for DynamicTupleStruct

impl<T> Reflect for Handle<T> where
    T: Asset, 

impl<T> Reflect for bevy::math::Rect<T> where
    T: Reflect + PartialEq<T>, 

impl<T> Reflect for Size<T> where
    T: Reflect + PartialEq<T>,