Trait bevy_internal::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<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 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 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 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 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> 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<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<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 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<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 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<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<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 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<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 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 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> 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 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<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<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 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 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 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 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<'_>>

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

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

Implementors

impl Reflect for HandleId

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 Children

impl Reflect for GlobalTransform

impl Reflect for Parent

impl Reflect for PreviousParent

impl Reflect for Transform

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 Rect<T> where
    T: Reflect + PartialEq<T>, 

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