Trait bevy::reflect::Reflect

pub trait Reflect: DynamicTypePath + Any + Send + Sync {
Show 19 methods // Required methods fn get_represented_type_info(&self) -> Option<&'static TypeInfo>; fn into_any(self: Box<Self>) -> Box<dyn Any>; fn as_any(&self) -> &(dyn Any + 'static); fn as_any_mut(&mut self) -> &mut (dyn Any + 'static); fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>; 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>) -> Result<(), Box<dyn Reflect>>; fn reflect_ref(&self) -> ReflectRef<'_>; fn reflect_mut(&mut self) -> ReflectMut<'_>; fn reflect_owned(self: Box<Self>) -> ReflectOwned; fn clone_value(&self) -> Box<dyn Reflect>; // Provided methods fn reflect_kind(&self) -> ReflectKind { ... } 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<'_>> { ... } fn is_dynamic(&self) -> bool { ... }
}
Expand description

The core trait of bevy_reflect, used for accessing and modifying data dynamically.

It’s recommended to use the derive macro rather than manually implementing this trait. Doing so will automatically implement many other useful traits for reflection, including one of the appropriate subtraits: Struct, TupleStruct or Enum.

See the crate-level documentation to see how this trait and its subtraits can be used.

Required Methods§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

For most types, this will simply return their own TypeInfo. However, for dynamic types, such as DynamicStruct or DynamicList, this will return the type they represent (or None if they don’t represent any particular 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>) -> Box<dyn Any>

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>) -> Box<dyn Reflect>

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>) -> Result<(), Box<dyn Reflect>>

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

Returns an owned enumeration of “kinds” of type.

See ReflectOwned.

fn clone_value(&self) -> Box<dyn Reflect>

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_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

See ReflectKind.

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.

Examples found in repository?
examples/reflection/reflection.rs (line 105)
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
fn setup(type_registry: Res<AppTypeRegistry>) {
    let mut value = Foo {
        a: 1,
        _ignored: NonReflectedValue { _a: 10 },
        nested: Bar { b: 8 },
    };

    // You can set field values like this. The type must match exactly or this will fail.
    *value.get_field_mut("a").unwrap() = 2usize;
    assert_eq!(value.a, 2);
    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);

    // You can also get the &dyn Reflect value of a field like this
    let field = value.field("a").unwrap();

    // you can downcast Reflect values like this:
    assert_eq!(*field.downcast_ref::<usize>().unwrap(), 2);

    // DynamicStruct also implements the `Struct` and `Reflect` traits.
    let mut patch = DynamicStruct::default();
    patch.insert("a", 4usize);

    // You can "apply" Reflect implementations on top of other Reflect implementations.
    // This will only set fields with the same name, and it will fail if the types don't match.
    // You can use this to "patch" your types with new values.
    value.apply(&patch);
    assert_eq!(value.a, 4);

    let type_registry = type_registry.read();
    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive
    // Serialize!
    let serializer = ReflectSerializer::new(&value, &type_registry);
    let ron_string =
        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
    info!("{}\n", ron_string);

    // Dynamic properties can be deserialized
    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();

    // Deserializing returns a Box<dyn Reflect> value. Generally, deserializing a value will return
    // the "dynamic" variant of a type. For example, deserializing a struct will return the
    // DynamicStruct type. "Value types" will be deserialized as themselves.
    let _deserialized_struct = reflect_value.downcast_ref::<DynamicStruct>();

    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
    // like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
    // `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
    assert!(reflect_value.reflect_partial_eq(&value).unwrap());

    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
    // This means we can serialize and deserialize with a single `Reflect` derive!
    value.apply(&*reflect_value);
}

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_path)", where type_path is the type path 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.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

Dynamic types include the ones built-in to this [crate], such as DynamicStruct, DynamicList, and DynamicTuple. However, they may be custom types used as proxies for other types or to facilitate scripting capabilities.

By default, this method will return false.

Implementations§

§

impl dyn Reflect

pub fn downcast<T>(self: Box<dyn Reflect>) -> Result<Box<T>, Box<dyn Reflect>>
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>) -> Result<T, Box<dyn Reflect>>
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).

Examples found in repository?
examples/reflection/reflection_types.rs (line 119)
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
fn setup() {
    let mut z = HashMap::default();
    z.insert("Hello".to_string(), 1.0);
    let value: Box<dyn Reflect> = Box::new(A {
        x: 1,
        y: vec![1, 2],
        z,
    });

    // There are a number of different "reflect traits", which each expose different operations on
    // the underlying type
    match value.reflect_ref() {
        // `Struct` is a trait automatically implemented for structs that derive Reflect. This trait
        // allows you to interact with fields via their string names or indices
        ReflectRef::Struct(value) => {
            info!(
                "This is a 'struct' type with an 'x' value of {}",
                value.get_field::<usize>("x").unwrap()
            );
        }
        // `TupleStruct` is a trait automatically implemented for tuple structs that derive Reflect.
        // This trait allows you to interact with fields via their indices
        ReflectRef::TupleStruct(_) => {}
        // `Tuple` is a special trait that can be manually implemented (instead of deriving
        // Reflect). This exposes "tuple" operations on your type, allowing you to interact
        // with fields via their indices. Tuple is automatically implemented for tuples of
        // arity 12 or less.
        ReflectRef::Tuple(_) => {}
        // `Enum` is a trait automatically implemented for enums that derive Reflect. This trait allows you
        // to interact with the current variant and its fields (if it has any)
        ReflectRef::Enum(_) => {}
        // `List` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "list" operations on your type, such as insertion. `List` is automatically
        // implemented for relevant core types like Vec<T>.
        ReflectRef::List(_) => {}
        // `Array` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "array" operations on your type, such as indexing. `Array`
        // is automatically implemented for relevant core types like [T; N].
        ReflectRef::Array(_) => {}
        // `Map` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "map" operations on your type, such as getting / inserting by key.
        // Map is automatically implemented for relevant core types like HashMap<K, V>
        ReflectRef::Map(_) => {}
        // `Value` types do not implement any of the other traits above. They are simply a Reflect
        // implementation. Value is implemented for core types like i32, usize, f32, and
        // String.
        ReflectRef::Value(_) => {}
    }

    let mut dynamic_list = DynamicList::default();
    dynamic_list.push(3u32);
    dynamic_list.push(4u32);
    dynamic_list.push(5u32);

    let mut value: A = value.take::<A>().unwrap();
    value.y.apply(&dynamic_list);
    assert_eq!(value.y, vec![3u32, 4u32, 5u32]);
}

pub fn represents<T>(&self) -> bool
where T: Reflect + TypePath,

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.

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

Downcasts the value to type T by reference.

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

Examples found in repository?
examples/reflection/reflection.rs (line 72)
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
fn setup(type_registry: Res<AppTypeRegistry>) {
    let mut value = Foo {
        a: 1,
        _ignored: NonReflectedValue { _a: 10 },
        nested: Bar { b: 8 },
    };

    // You can set field values like this. The type must match exactly or this will fail.
    *value.get_field_mut("a").unwrap() = 2usize;
    assert_eq!(value.a, 2);
    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);

    // You can also get the &dyn Reflect value of a field like this
    let field = value.field("a").unwrap();

    // you can downcast Reflect values like this:
    assert_eq!(*field.downcast_ref::<usize>().unwrap(), 2);

    // DynamicStruct also implements the `Struct` and `Reflect` traits.
    let mut patch = DynamicStruct::default();
    patch.insert("a", 4usize);

    // You can "apply" Reflect implementations on top of other Reflect implementations.
    // This will only set fields with the same name, and it will fail if the types don't match.
    // You can use this to "patch" your types with new values.
    value.apply(&patch);
    assert_eq!(value.a, 4);

    let type_registry = type_registry.read();
    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive
    // Serialize!
    let serializer = ReflectSerializer::new(&value, &type_registry);
    let ron_string =
        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
    info!("{}\n", ron_string);

    // Dynamic properties can be deserialized
    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();

    // Deserializing returns a Box<dyn Reflect> value. Generally, deserializing a value will return
    // the "dynamic" variant of a type. For example, deserializing a struct will return the
    // DynamicStruct type. "Value types" will be deserialized as themselves.
    let _deserialized_struct = reflect_value.downcast_ref::<DynamicStruct>();

    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves
    // like normal `partial_eq`, but it treats "dynamic" and "non-dynamic" types the same. The
    // `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
    assert!(reflect_value.reflect_partial_eq(&value).unwrap());

    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
    // This means we can serialize and deserialize with a single `Reflect` derive!
    value.apply(&*reflect_value);
}

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

Downcasts the value to type T by mutable reference.

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

Trait Implementations§

§

impl Debug for dyn Reflect

§

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

Formats the value using the given formatter. Read more
§

impl TypePath for dyn Reflect

§

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type. Read more
§

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type. Read more
§

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous. Read more
§

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous. Read more
§

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous. Read more
§

impl Typed for dyn Reflect

§

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

Implementations on Foreign Types§

§

impl Reflect for &'static str

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<&'static str>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<&'static str>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

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

§

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

§

fn reflect_owned(self: Box<&'static str>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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>

§

impl Reflect for &'static Path

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<&'static Path>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<&'static Path>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<&'static Path>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

impl Reflect for Cow<'static, str>

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Cow<'static, str>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Cow<'static, str>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Cow<'static, str>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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>

§

impl Reflect for Cow<'static, Path>

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Cow<'static, Path>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Cow<'static, Path>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Cow<'static, Path>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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>

§

impl Reflect for bool
where bool: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<bool>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<bool>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<bool>) -> ReflectOwned

§

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>

§

impl Reflect for char
where char: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<char>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<char>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<char>) -> ReflectOwned

§

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>

§

impl Reflect for f32
where f32: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<f32>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<f32>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<f32>) -> ReflectOwned

§

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

§

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

§

impl Reflect for f64
where f64: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<f64>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<f64>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<f64>) -> ReflectOwned

§

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

§

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

§

impl Reflect for i8
where i8: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<i8>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<i8>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<i8>) -> ReflectOwned

§

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>

§

impl Reflect for i16
where i16: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<i16>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<i16>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<i16>) -> ReflectOwned

§

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>

§

impl Reflect for i32
where i32: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<i32>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<i32>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<i32>) -> ReflectOwned

§

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>

§

impl Reflect for i64
where i64: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<i64>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<i64>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<i64>) -> ReflectOwned

§

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>

§

impl Reflect for i128
where i128: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<i128>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<i128>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<i128>) -> ReflectOwned

§

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>

§

impl Reflect for isize
where isize: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<isize>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<isize>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<isize>) -> ReflectOwned

§

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>

§

impl Reflect for u8
where u8: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<u8>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<u8>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<u8>) -> ReflectOwned

§

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>

§

impl Reflect for u16
where u16: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<u16>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<u16>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<u16>) -> ReflectOwned

§

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>

§

impl Reflect for u32
where u32: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<u32>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<u32>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<u32>) -> ReflectOwned

§

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>

§

impl Reflect for u64
where u64: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<u64>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<u64>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<u64>) -> ReflectOwned

§

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>

§

impl Reflect for u128
where u128: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<u128>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<u128>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<u128>) -> ReflectOwned

§

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>

§

impl Reflect for ()

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<()>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<()>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<()>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

impl Reflect for usize
where usize: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<usize>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<usize>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<usize>) -> ReflectOwned

§

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>

§

impl Reflect for String
where String: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<String>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<String>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<String>) -> ReflectOwned

§

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>

§

impl Reflect for TypeId
where TypeId: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<TypeId>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<TypeId>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<TypeId>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<i8>
where NonZero<i8>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<i8>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<i8>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<i8>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<i16>
where NonZero<i16>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<i16>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<i16>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<i16>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<i32>
where NonZero<i32>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<i32>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<i32>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<i32>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<i64>
where NonZero<i64>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<i64>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<i64>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<i64>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<i128>
where NonZero<i128>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<i128>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<i128>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<i128>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<isize>
where NonZero<isize>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<isize>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<isize>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<isize>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<u8>
where NonZero<u8>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<u8>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<u8>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<u8>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<u16>
where NonZero<u16>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<u16>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<u16>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<u16>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<u32>
where NonZero<u32>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<u32>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<u32>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<u32>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<u64>
where NonZero<u64>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<u64>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<u64>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<u64>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<u128>
where NonZero<u128>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<u128>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<u128>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<u128>>) -> ReflectOwned

§

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>

§

impl Reflect for NonZero<usize>
where NonZero<usize>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NonZero<usize>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NonZero<usize>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NonZero<usize>>) -> ReflectOwned

§

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>

§

impl Reflect for RangeFull
where RangeFull: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<RangeFull>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<RangeFull>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<RangeFull>) -> ReflectOwned

§

impl Reflect for OsString
where OsString: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<OsString>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<OsString>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<OsString>) -> ReflectOwned

§

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>

§

impl Reflect for PathBuf
where PathBuf: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<PathBuf>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<PathBuf>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<PathBuf>) -> ReflectOwned

§

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>

§

impl Reflect for NodeIndex
where NodeIndex: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<NodeIndex>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<NodeIndex>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<NodeIndex>) -> ReflectOwned

§

impl Reflect for Uuid
where Uuid: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Uuid>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Uuid>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Uuid>) -> ReflectOwned

§

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>

§

impl Reflect for SmolStr
where SmolStr: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<SmolStr>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<SmolStr>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<SmolStr>) -> ReflectOwned

§

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>

§

impl<A> Reflect for (A,)

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A,)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A,)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A,)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C, D)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C, D, E)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E, F)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C, D, E, F)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E, F, G)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C, D, E, F, G)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E, F, G, H)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C, D, E, F, G, H)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C, D, E, F, G, H, I)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H, I)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I, J)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<(A, B, C, D, E, F, G, H, I, J)>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H, I, J)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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)

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I, J, K)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect( self: Box<(A, B, C, D, E, F, G, H, I, J, K)> ) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<(A, B, C, D, E, F, G, H, I, J, K)>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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)

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<(A, B, C, D, E, F, G, H, I, J, K, L)>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect( self: Box<(A, B, C, D, E, F, G, H, I, J, K, L)> ) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned( self: Box<(A, B, C, D, E, F, G, H, I, J, K, L)> ) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

impl<K, V> Reflect for BTreeMap<K, V>

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<BTreeMap<K, V>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<BTreeMap<K, V>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<BTreeMap<K, V>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

impl<K, V, S> Reflect for HashMap<K, V, S>

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<HashMap<K, V, S>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<HashMap<K, V, S>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<HashMap<K, V, S>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

impl<N, E, Ix> Reflect for Graph<N, E, Directed, Ix>
where N: Clone + TypePath, E: Clone + TypePath, Ix: IndexType + TypePath, Graph<N, E, Directed, Ix>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Graph<N, E, Directed, Ix>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Graph<N, E, Directed, Ix>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Graph<N, E, Directed, Ix>>) -> ReflectOwned

§

impl<T> Reflect for Cow<'static, [T]>

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Cow<'static, [T]>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Cow<'static, [T]>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Cow<'static, [T]>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

impl<T> Reflect for Option<T>
where Option<T>: Any + Send + Sync, T: TypePath + FromReflect + RegisterForReflection,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Option<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Option<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

fn set( &mut self, __value_param: Box<dyn Reflect> ) -> Result<(), Box<dyn Reflect>>

§

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

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Option<T>>) -> ReflectOwned

§

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

§

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

§

impl<T> Reflect for BinaryHeap<T>
where T: Clone + TypePath, BinaryHeap<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<BinaryHeap<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<BinaryHeap<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<BinaryHeap<T>>) -> ReflectOwned

§

impl<T> Reflect for BTreeSet<T>
where T: Ord + Eq + Clone + Send + Sync + TypePath, BTreeSet<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<BTreeSet<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<BTreeSet<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<BTreeSet<T>>) -> ReflectOwned

§

impl<T> Reflect for VecDeque<T>

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<VecDeque<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<VecDeque<T>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<VecDeque<T>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

impl<T> Reflect for Arc<T>
where T: Send + Sync + TypePath, Arc<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Arc<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Arc<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Arc<T>>) -> ReflectOwned

§

impl<T> Reflect for Vec<T>

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Vec<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Vec<T>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Vec<T>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

§

impl<T> Reflect for Saturating<T>
where T: Clone + Send + Sync + TypePath, Saturating<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Saturating<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Saturating<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Saturating<T>>) -> ReflectOwned

§

impl<T> Reflect for Wrapping<T>
where T: Clone + Send + Sync + TypePath, Wrapping<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Wrapping<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Wrapping<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Wrapping<T>>) -> ReflectOwned

§

impl<T> Reflect for Range<T>
where T: Clone + Send + Sync + TypePath, Range<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Range<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Range<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Range<T>>) -> ReflectOwned

§

impl<T> Reflect for RangeFrom<T>
where T: Clone + Send + Sync + TypePath, RangeFrom<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<RangeFrom<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<RangeFrom<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<RangeFrom<T>>) -> ReflectOwned

§

impl<T> Reflect for RangeInclusive<T>
where T: Clone + Send + Sync + TypePath, RangeInclusive<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<RangeInclusive<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<RangeInclusive<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<RangeInclusive<T>>) -> ReflectOwned

§

impl<T> Reflect for RangeTo<T>
where T: Clone + Send + Sync + TypePath, RangeTo<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<RangeTo<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<RangeTo<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<RangeTo<T>>) -> ReflectOwned

§

impl<T> Reflect for RangeToInclusive<T>
where T: Clone + Send + Sync + TypePath, RangeToInclusive<T>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<RangeToInclusive<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<RangeToInclusive<T>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<RangeToInclusive<T>>) -> ReflectOwned

§

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

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<SmallVec<T>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<SmallVec<T>>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<SmallVec<T>>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

impl<T, E> Reflect for Result<T, E>
where T: Clone + Reflect + TypePath, E: Clone + Reflect + TypePath, Result<T, E>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<Result<T, E>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<Result<T, E>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<Result<T, E>>) -> ReflectOwned

§

impl<T, S> Reflect for HashSet<T, S>
where T: Hash + Eq + Clone + Send + Sync + TypePath, S: TypePath + Clone + Send + Sync, HashSet<T, S>: Any + Send + Sync,

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<HashSet<T, S>>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<HashSet<T, S>>) -> Box<dyn Reflect>

§

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

§

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

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<HashSet<T, S>>) -> ReflectOwned

§

impl<T, const N: usize> Reflect for [T; N]

§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§

fn into_any(self: Box<[T; N]>) -> Box<dyn Any>

§

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

§

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

§

fn into_reflect(self: Box<[T; N]>) -> Box<dyn Reflect>

§

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>) -> Result<(), Box<dyn Reflect>>

§

fn reflect_kind(&self) -> ReflectKind

§

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

§

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

§

fn reflect_owned(self: Box<[T; N]>) -> ReflectOwned

§

fn clone_value(&self) -> Box<dyn Reflect>

§

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

§

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

Implementors§

§

impl Reflect for Interpolation

§

impl Reflect for Keyframes
where Keyframes: Any + Send + Sync, Vec<Quat>: FromReflect + TypePath + RegisterForReflection, Vec<Vec3>: FromReflect + TypePath + RegisterForReflection, Vec<f32>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for RepeatAnimation
where RepeatAnimation: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PlaybackMode

§

impl Reflect for Color
where Color: Any + Send + Sync, Srgba: FromReflect + TypePath + RegisterForReflection, LinearRgba: FromReflect + TypePath + RegisterForReflection, Hsla: FromReflect + TypePath + RegisterForReflection, Hsva: FromReflect + TypePath + RegisterForReflection, Hwba: FromReflect + TypePath + RegisterForReflection, Laba: FromReflect + TypePath + RegisterForReflection, Lcha: FromReflect + TypePath + RegisterForReflection, Oklaba: FromReflect + TypePath + RegisterForReflection, Oklcha: FromReflect + TypePath + RegisterForReflection, Xyza: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BloomCompositeMode

§

impl Reflect for Camera3dDepthLoadOp
where Camera3dDepthLoadOp: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ScreenSpaceTransmissionQuality

§

impl Reflect for Sensitivity
where Sensitivity: Any + Send + Sync,

§

impl Reflect for DebandDither

§

impl Reflect for Tonemapping
where Tonemapping: Any + Send + Sync,

§

impl Reflect for GizmoLineJoint
where GizmoLineJoint: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GizmoLineStyle

§

impl Reflect for LightGizmoColor
where LightGizmoColor: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ButtonState
where ButtonState: Any + Send + Sync,

§

impl Reflect for GamepadAxisType
where GamepadAxisType: Any + Send + Sync, u8: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadButtonType
where GamepadButtonType: Any + Send + Sync, u8: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadConnection
where GamepadConnection: Any + Send + Sync, GamepadInfo: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadEvent
where GamepadEvent: Any + Send + Sync, GamepadConnectionEvent: FromReflect + TypePath + RegisterForReflection, GamepadButtonChangedEvent: FromReflect + TypePath + RegisterForReflection, GamepadAxisChangedEvent: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Key
where Key: Any + Send + Sync, SmolStr: FromReflect + TypePath + RegisterForReflection, NativeKey: FromReflect + TypePath + RegisterForReflection, Option<char>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for KeyCode
where KeyCode: Any + Send + Sync, NativeKeyCode: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for NativeKey
where NativeKey: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection, u16: FromReflect + TypePath + RegisterForReflection, SmolStr: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for NativeKeyCode
where NativeKeyCode: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection, u16: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MouseButton
where MouseButton: Any + Send + Sync, u16: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MouseScrollUnit

§

impl Reflect for ForceTouch
where ForceTouch: Any + Send + Sync, f64: FromReflect + TypePath + RegisterForReflection, Option<f64>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TouchPhase
where TouchPhase: Any + Send + Sync,

§

impl Reflect for EulerRot
where EulerRot: Any + Send + Sync,

§

impl Reflect for ClusterConfig
where ClusterConfig: Any + Send + Sync, UVec3: FromReflect + TypePath + RegisterForReflection, ClusterZConfig: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ClusterFarZMode
where ClusterFarZMode: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for FogFalloff
where FogFalloff: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, Vec3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for OpaqueRendererMethod

§

impl Reflect for ParallaxMappingMethod
where ParallaxMappingMethod: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ScreenSpaceAmbientOcclusionQualityLevel

§

impl Reflect for ShadowFilteringMethod

§

impl Reflect for AlphaMode
where AlphaMode: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ClearColorConfig
where ClearColorConfig: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for NormalizedRenderTarget
where NormalizedRenderTarget: Any + Send + Sync, NormalizedWindowRef: FromReflect + TypePath + RegisterForReflection, Handle<Image>: FromReflect + TypePath + RegisterForReflection, ManualTextureViewHandle: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Projection
where Projection: Any + Send + Sync, PerspectiveProjection: FromReflect + TypePath + RegisterForReflection, OrthographicProjection: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for RenderTarget
where RenderTarget: Any + Send + Sync, WindowRef: FromReflect + TypePath + RegisterForReflection, Handle<Image>: FromReflect + TypePath + RegisterForReflection, ManualTextureViewHandle: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ScalingMode
where ScalingMode: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Indices
where Indices: Any + Send + Sync, Vec<u16>: FromReflect + TypePath + RegisterForReflection, Vec<u32>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Msaa
where Msaa: Any + Send + Sync,

§

impl Reflect for Visibility
where Visibility: Any + Send + Sync,

§

impl Reflect for Anchor
where Anchor: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ImageScaleMode
where ImageScaleMode: Any + Send + Sync, TextureSlicer: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for SliceScaleMode
where SliceScaleMode: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BreakLineOn
where BreakLineOn: Any + Send + Sync,

§

impl Reflect for JustifyText
where JustifyText: Any + Send + Sync,

§

impl Reflect for TimerMode
where TimerMode: Any + Send + Sync,

§

impl Reflect for AlignContent

§

impl Reflect for AlignItems
where AlignItems: Any + Send + Sync,

§

impl Reflect for AlignSelf
where AlignSelf: Any + Send + Sync,

§

impl Reflect for Direction
where Direction: Any + Send + Sync,

§

impl Reflect for Display
where Display: Any + Send + Sync,

§

impl Reflect for FlexDirection

§

impl Reflect for FlexWrap
where FlexWrap: Any + Send + Sync,

§

impl Reflect for FocusPolicy
where FocusPolicy: Any + Send + Sync,

§

impl Reflect for GridAutoFlow

§

impl Reflect for GridTrackRepetition
where GridTrackRepetition: Any + Send + Sync, u16: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Interaction
where Interaction: Any + Send + Sync,

§

impl Reflect for JustifyContent

§

impl Reflect for JustifyItems

§

impl Reflect for JustifySelf
where JustifySelf: Any + Send + Sync,

§

impl Reflect for MaxTrackSizingFunction

§

impl Reflect for MinTrackSizingFunction

§

impl Reflect for OverflowAxis

§

impl Reflect for PositionType

§

impl Reflect for Val
where Val: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ZIndex
where ZIndex: Any + Send + Sync, i32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ApplicationLifetime

§

impl Reflect for CompositeAlphaMode

§

impl Reflect for CursorGrabMode

§

impl Reflect for CursorIcon
where CursorIcon: Any + Send + Sync,

§

impl Reflect for FileDragAndDrop
where FileDragAndDrop: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, PathBuf: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Ime
where Ime: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, String: FromReflect + TypePath + RegisterForReflection, Option<(usize, usize)>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MonitorSelection
where MonitorSelection: Any + Send + Sync, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PresentMode
where PresentMode: Any + Send + Sync,

§

impl Reflect for WindowLevel
where WindowLevel: Any + Send + Sync,

§

impl Reflect for WindowMode
where WindowMode: Any + Send + Sync,

§

impl Reflect for WindowPosition
where WindowPosition: Any + Send + Sync, MonitorSelection: FromReflect + TypePath + RegisterForReflection, IVec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowRef
where WindowRef: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowTheme
where WindowTheme: Any + Send + Sync,

§

impl Reflect for WinitEvent
where WinitEvent: Any + Send + Sync, ApplicationLifetime: FromReflect + TypePath + RegisterForReflection, CursorEntered: FromReflect + TypePath + RegisterForReflection, CursorLeft: FromReflect + TypePath + RegisterForReflection, CursorMoved: FromReflect + TypePath + RegisterForReflection, FileDragAndDrop: FromReflect + TypePath + RegisterForReflection, Ime: FromReflect + TypePath + RegisterForReflection, ReceivedCharacter: FromReflect + TypePath + RegisterForReflection, RequestRedraw: FromReflect + TypePath + RegisterForReflection, WindowBackendScaleFactorChanged: FromReflect + TypePath + RegisterForReflection, WindowCloseRequested: FromReflect + TypePath + RegisterForReflection, WindowCreated: FromReflect + TypePath + RegisterForReflection, WindowDestroyed: FromReflect + TypePath + RegisterForReflection, WindowFocused: FromReflect + TypePath + RegisterForReflection, WindowMoved: FromReflect + TypePath + RegisterForReflection, WindowOccluded: FromReflect + TypePath + RegisterForReflection, WindowResized: FromReflect + TypePath + RegisterForReflection, WindowScaleFactorChanged: FromReflect + TypePath + RegisterForReflection, WindowThemeChanged: FromReflect + TypePath + RegisterForReflection, MouseButtonInput: FromReflect + TypePath + RegisterForReflection, MouseMotion: FromReflect + TypePath + RegisterForReflection, MouseWheel: FromReflect + TypePath + RegisterForReflection, TouchpadMagnify: FromReflect + TypePath + RegisterForReflection, TouchpadRotate: FromReflect + TypePath + RegisterForReflection, TouchInput: FromReflect + TypePath + RegisterForReflection, KeyboardInput: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationGraph
where AnimationGraph: Any + Send + Sync, Graph<AnimationGraphNode, ()>: FromReflect + TypePath + RegisterForReflection, NodeIndex: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationGraphNode
where AnimationGraphNode: Any + Send + Sync, Option<Handle<AnimationClip>>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationTransition
where AnimationTransition: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, NodeIndex: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationTransitions
where AnimationTransitions: Any + Send + Sync, Option<NodeIndex>: FromReflect + TypePath + RegisterForReflection, Vec<AnimationTransition>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ActiveAnimation
where ActiveAnimation: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, RepeatAnimation: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationClip
where AnimationClip: Any + Send + Sync, HashMap<AnimationTargetId, Vec<VariableCurve>, NoOpHash>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationPlayer
where AnimationPlayer: Any + Send + Sync, BTreeMap<NodeIndex, ActiveAnimation>: FromReflect + TypePath + RegisterForReflection, HashMap<NodeIndex, f32>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationTarget
where AnimationTarget: Any + Send + Sync, AnimationTargetId: FromReflect + TypePath + RegisterForReflection, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AnimationTargetId
where AnimationTargetId: Any + Send + Sync, Uuid: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for VariableCurve
where VariableCurve: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + RegisterForReflection, Keyframes: FromReflect + TypePath + RegisterForReflection, Interpolation: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AssetIndex
where AssetIndex: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DefaultSpatialScale
where DefaultSpatialScale: Any + Send + Sync, SpatialScale: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GlobalVolume
where GlobalVolume: Any + Send + Sync, Volume: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PlaybackSettings
where PlaybackSettings: Any + Send + Sync, PlaybackMode: FromReflect + TypePath + RegisterForReflection, Volume: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, Option<SpatialScale>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for SpatialListener
where SpatialListener: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for SpatialScale
where SpatialScale: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Volume
where Volume: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Hsla
where Hsla: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Hsva
where Hsva: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Hwba
where Hwba: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Laba
where Laba: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Lcha
where Lcha: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for LinearRgba
where LinearRgba: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Oklaba
where Oklaba: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Oklcha
where Oklcha: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Srgba
where Srgba: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Xyza
where Xyza: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Name
where Name: Any + Send + Sync, u64: FromReflect + TypePath + RegisterForReflection, Cow<'static, str>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BloomPrefilterSettings
where BloomPrefilterSettings: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BloomSettings
where BloomSettings: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, BloomPrefilterSettings: FromReflect + TypePath + RegisterForReflection, BloomCompositeMode: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ContrastAdaptiveSharpeningSettings
where ContrastAdaptiveSharpeningSettings: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DenoiseCAS
where DenoiseCAS: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Camera2d
where Camera2d: Any + Send + Sync,

§

impl Reflect for Camera3d
where Camera3d: Any + Send + Sync, Camera3dDepthLoadOp: FromReflect + TypePath + RegisterForReflection, Camera3dDepthTextureUsage: FromReflect + TypePath + RegisterForReflection, usize: FromReflect + TypePath + RegisterForReflection, ScreenSpaceTransmissionQuality: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Camera3dDepthTextureUsage
where Camera3dDepthTextureUsage: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TemporalAntiAliasSettings
where TemporalAntiAliasSettings: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Fxaa
where Fxaa: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection, Sensitivity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DeferredPrepass

§

impl Reflect for DepthPrepass

§

impl Reflect for MotionVectorPrepass

§

impl Reflect for NormalPrepass

§

impl Reflect for ComponentId
where ComponentId: Any + Send + Sync, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ComponentTicks
where ComponentTicks: Any + Send + Sync, Tick: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Tick
where Tick: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Entity
where Entity: Any + Send + Sync,

§

impl Reflect for EntityHash
where EntityHash: Any + Send + Sync,

§

impl Reflect for AabbGizmoConfigGroup
where AabbGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection, Option<Color>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ShowAabbGizmo
where ShowAabbGizmo: Any + Send + Sync, Option<Color>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DefaultGizmoConfigGroup

§

impl Reflect for GizmoConfig
where GizmoConfig: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, GizmoLineStyle: FromReflect + TypePath + RegisterForReflection, RenderLayers: FromReflect + TypePath + RegisterForReflection, GizmoLineJoint: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GizmoConfigStore

§

impl Reflect for LightGizmoConfigGroup
where LightGizmoConfigGroup: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection, LightGizmoColor: FromReflect + TypePath + RegisterForReflection, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ShowLightGizmo
where ShowLightGizmo: Any + Send + Sync, Option<LightGizmoColor>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GltfExtras
where GltfExtras: Any + Send + Sync, String: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Children
where Children: Any + Send + Sync, SmallVec<[Entity; 8]>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Parent
where Parent: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AxisSettings
where AxisSettings: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ButtonAxisSettings
where ButtonAxisSettings: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ButtonSettings
where ButtonSettings: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Gamepad
where Gamepad: Any + Send + Sync, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadAxis
where GamepadAxis: Any + Send + Sync, Gamepad: FromReflect + TypePath + RegisterForReflection, GamepadAxisType: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadAxisChangedEvent
where GamepadAxisChangedEvent: Any + Send + Sync, Gamepad: FromReflect + TypePath + RegisterForReflection, GamepadAxisType: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadButton
where GamepadButton: Any + Send + Sync, Gamepad: FromReflect + TypePath + RegisterForReflection, GamepadButtonType: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadButtonChangedEvent
where GamepadButtonChangedEvent: Any + Send + Sync, Gamepad: FromReflect + TypePath + RegisterForReflection, GamepadButtonType: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadButtonInput
where GamepadButtonInput: Any + Send + Sync, GamepadButton: FromReflect + TypePath + RegisterForReflection, ButtonState: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadConnectionEvent
where GamepadConnectionEvent: Any + Send + Sync, Gamepad: FromReflect + TypePath + RegisterForReflection, GamepadConnection: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadInfo
where GamepadInfo: Any + Send + Sync, String: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GamepadSettings
where GamepadSettings: Any + Send + Sync, ButtonSettings: FromReflect + TypePath + RegisterForReflection, AxisSettings: FromReflect + TypePath + RegisterForReflection, ButtonAxisSettings: FromReflect + TypePath + RegisterForReflection, HashMap<GamepadButton, ButtonSettings>: FromReflect + TypePath + RegisterForReflection, HashMap<GamepadAxis, AxisSettings>: FromReflect + TypePath + RegisterForReflection, HashMap<GamepadButton, ButtonAxisSettings>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for KeyboardInput
where KeyboardInput: Any + Send + Sync, KeyCode: FromReflect + TypePath + RegisterForReflection, Key: FromReflect + TypePath + RegisterForReflection, ButtonState: FromReflect + TypePath + RegisterForReflection, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MouseButtonInput
where MouseButtonInput: Any + Send + Sync, MouseButton: FromReflect + TypePath + RegisterForReflection, ButtonState: FromReflect + TypePath + RegisterForReflection, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MouseMotion
where MouseMotion: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MouseWheel
where MouseWheel: Any + Send + Sync, MouseScrollUnit: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TouchInput
where TouchInput: Any + Send + Sync, TouchPhase: FromReflect + TypePath + RegisterForReflection, Vec2: FromReflect + TypePath + RegisterForReflection, Entity: FromReflect + TypePath + RegisterForReflection, Option<ForceTouch>: FromReflect + TypePath + RegisterForReflection, u64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TouchpadMagnify
where TouchpadMagnify: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TouchpadRotate
where TouchpadRotate: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BVec2
where BVec2: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BVec3
where BVec3: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BVec4
where BVec4: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Mat2
where Mat2: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Mat3
where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Mat4
where Mat4: Any + Send + Sync, Vec4: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Quat
where Quat: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Vec2
where Vec2: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Vec3
where Vec3: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Vec3A
where Vec3A: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Vec4
where Vec4: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for IVec2
where IVec2: Any + Send + Sync, i32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for IVec3
where IVec3: Any + Send + Sync, i32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for IVec4
where IVec4: Any + Send + Sync, i32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Capsule2d
where Capsule2d: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Capsule3d
where Capsule3d: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Circle
where Circle: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Cone
where Cone: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ConicalFrustum
where ConicalFrustum: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Cuboid
where Cuboid: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Cylinder
where Cylinder: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Ellipse
where Ellipse: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Line2d
where Line2d: Any + Send + Sync, Dir2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Line3d
where Line3d: Any + Send + Sync, Dir3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Plane2d
where Plane2d: Any + Send + Sync, Dir2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Plane3d
where Plane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Rectangle
where Rectangle: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for RegularPolygon
where RegularPolygon: Any + Send + Sync, Circle: FromReflect + TypePath + RegisterForReflection, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Segment2d
where Segment2d: Any + Send + Sync, Dir2: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Segment3d
where Segment3d: Any + Send + Sync, Dir3: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Sphere
where Sphere: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Torus
where Torus: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Triangle2d
where Triangle2d: Any + Send + Sync, [Vec2; 3]: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Affine2
where Affine2: Any + Send + Sync, Mat2: FromReflect + TypePath + RegisterForReflection, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Affine3A
where Affine3A: Any + Send + Sync, Mat3A: FromReflect + TypePath + RegisterForReflection, Vec3A: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BVec3A
where BVec3A: Any + Send + Sync,

§

impl Reflect for BVec4A
where BVec4A: Any + Send + Sync,

§

impl Reflect for DAffine2
where DAffine2: Any + Send + Sync, DMat2: FromReflect + TypePath + RegisterForReflection, DVec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DAffine3
where DAffine3: Any + Send + Sync, DMat3: FromReflect + TypePath + RegisterForReflection, DVec3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DMat2
where DMat2: Any + Send + Sync, DVec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DMat3
where DMat3: Any + Send + Sync, DVec3: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DMat4
where DMat4: Any + Send + Sync, DVec4: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DQuat
where DQuat: Any + Send + Sync, f64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DVec2
where DVec2: Any + Send + Sync, f64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DVec3
where DVec3: Any + Send + Sync, f64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DVec4
where DVec4: Any + Send + Sync, f64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Dir2
where Dir2: Any + Send + Sync,

§

impl Reflect for Dir3
where Dir3: Any + Send + Sync,

§

impl Reflect for Dir3A
where Dir3A: Any + Send + Sync,

§

impl Reflect for I64Vec2
where I64Vec2: Any + Send + Sync, i64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for I64Vec3
where I64Vec3: Any + Send + Sync, i64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for I64Vec4
where I64Vec4: Any + Send + Sync, i64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for IRect
where IRect: Any + Send + Sync, IVec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Mat3A
where Mat3A: Any + Send + Sync, Vec3A: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Rect
where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Rotation2d
where Rotation2d: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for U64Vec2
where U64Vec2: Any + Send + Sync, u64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for U64Vec3
where U64Vec3: Any + Send + Sync, u64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for U64Vec4
where U64Vec4: Any + Send + Sync, u64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for URect
where URect: Any + Send + Sync, UVec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for UVec2
where UVec2: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for UVec3
where UVec3: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for UVec4
where UVec4: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for EnvironmentMapLight
where EnvironmentMapLight: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for IrradianceVolume
where IrradianceVolume: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for AmbientLight
where AmbientLight: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Cascade
where Cascade: Any + Send + Sync, Mat4: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CascadeShadowConfig
where CascadeShadowConfig: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Cascades
where Cascades: Any + Send + Sync, HashMap<Entity, Vec<Cascade>, EntityHash>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CascadesVisibleEntities

§

impl Reflect for ClusterZConfig
where ClusterZConfig: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, ClusterFarZMode: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CubemapVisibleEntities

§

impl Reflect for DefaultOpaqueRendererMethod

§

impl Reflect for DirectionalLight
where DirectionalLight: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DirectionalLightShadowMap
where DirectionalLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for FogSettings
where FogSettings: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, FogFalloff: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for LightProbe
where LightProbe: Any + Send + Sync,

§

impl Reflect for Lightmap
where Lightmap: Any + Send + Sync, Handle<Image>: FromReflect + TypePath + RegisterForReflection, Rect: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for NotShadowCaster

§

impl Reflect for NotShadowReceiver

§

impl Reflect for PointLight
where PointLight: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PointLightShadowMap
where PointLightShadowMap: Any + Send + Sync, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ScreenSpaceAmbientOcclusionSettings

§

impl Reflect for SpotLight
where SpotLight: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for StandardMaterial
where StandardMaterial: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, AlphaMode: FromReflect + TypePath + RegisterForReflection, ParallaxMappingMethod: FromReflect + TypePath + RegisterForReflection, OpaqueRendererMethod: FromReflect + TypePath + RegisterForReflection, u8: FromReflect + TypePath + RegisterForReflection, Affine2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TransmittedShadowReceiver

§

impl Reflect for NoWireframe
where NoWireframe: Any + Send + Sync,

§

impl Reflect for Wireframe
where Wireframe: Any + Send + Sync,

§

impl Reflect for WireframeColor
where WireframeColor: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WireframeConfig
where WireframeConfig: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Camera
where Camera: Any + Send + Sync, Option<Viewport>: FromReflect + TypePath + RegisterForReflection, isize: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, ClearColorConfig: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CameraMainTextureUsages

§

impl Reflect for CameraRenderGraph

§

impl Reflect for ClearColor
where ClearColor: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Exposure
where Exposure: Any + Send + Sync,

§

impl Reflect for ManualTextureViewHandle
where ManualTextureViewHandle: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MipBias
where MipBias: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for OrthographicProjection
where OrthographicProjection: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, Vec2: FromReflect + TypePath + RegisterForReflection, ScalingMode: FromReflect + TypePath + RegisterForReflection, Rect: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PerspectiveProjection
where PerspectiveProjection: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TemporalJitter
where TemporalJitter: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Viewport
where Viewport: Any + Send + Sync, UVec2: FromReflect + TypePath + RegisterForReflection, Range<f32>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GlobalsUniform
where GlobalsUniform: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MeshMorphWeights
where MeshMorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MorphWeights
where MorphWeights: Any + Send + Sync, Vec<f32>: FromReflect + TypePath + RegisterForReflection, Option<Handle<Mesh>>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for SkinnedMesh
where SkinnedMesh: Any + Send + Sync, Handle<SkinnedMeshInverseBindposes>: FromReflect + TypePath + RegisterForReflection, Vec<Entity>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Mesh
where Mesh: Any + Send + Sync, Option<Indices>: FromReflect + TypePath + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + RegisterForReflection, Option<Vec<String>>: FromReflect + TypePath + RegisterForReflection, RenderAssetUsages: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Aabb
where Aabb: Any + Send + Sync, Vec3A: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CascadesFrusta

§

impl Reflect for CubemapFrusta

§

impl Reflect for Frustum
where Frustum: Any + Send + Sync,

§

impl Reflect for RenderAssetUsages

§

impl Reflect for Image
where Image: Any + Send + Sync,

§

impl Reflect for ColorGrading
where ColorGrading: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for InheritedVisibility
where InheritedVisibility: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for NoFrustumCulling

§

impl Reflect for RenderLayers
where RenderLayers: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ViewVisibility
where ViewVisibility: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for VisibleEntities

§

impl Reflect for BorderRect
where BorderRect: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ColorMaterial
where ColorMaterial: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, Option<Handle<Image>>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Mesh2dHandle
where Mesh2dHandle: Any + Send + Sync, Handle<Mesh>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Sprite
where Sprite: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + RegisterForReflection, Option<Rect>: FromReflect + TypePath + RegisterForReflection, Anchor: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TextureAtlas
where TextureAtlas: Any + Send + Sync, Handle<TextureAtlasLayout>: FromReflect + TypePath + RegisterForReflection, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TextureAtlasLayout
where TextureAtlasLayout: Any + Send + Sync, UVec2: FromReflect + TypePath + RegisterForReflection, Vec<URect>: FromReflect + TypePath + RegisterForReflection, Option<HashMap<AssetId<Image>, usize>>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TextureSlicer
where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath + RegisterForReflection, SliceScaleMode: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GlyphAtlasInfo
where GlyphAtlasInfo: Any + Send + Sync, Handle<TextureAtlasLayout>: FromReflect + TypePath + RegisterForReflection, Handle<Image>: FromReflect + TypePath + RegisterForReflection, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PositionedGlyph
where PositionedGlyph: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection, GlyphAtlasInfo: FromReflect + TypePath + RegisterForReflection, usize: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Text2dBounds
where Text2dBounds: Any + Send + Sync, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Text
where Text: Any + Send + Sync, Vec<TextSection>: FromReflect + TypePath + RegisterForReflection, JustifyText: FromReflect + TypePath + RegisterForReflection, BreakLineOn: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TextLayoutInfo
where TextLayoutInfo: Any + Send + Sync, Vec<PositionedGlyph>: FromReflect + TypePath + RegisterForReflection, Vec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TextSection
where TextSection: Any + Send + Sync, String: FromReflect + TypePath + RegisterForReflection, TextStyle: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TextStyle
where TextStyle: Any + Send + Sync, Handle<Font>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Fixed
where Fixed: Any + Send + Sync, Duration: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Real
where Real: Any + Send + Sync, Instant: FromReflect + TypePath + RegisterForReflection, Option<Instant>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Stopwatch
where Stopwatch: Any + Send + Sync, Duration: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + RegisterForReflection, Duration: FromReflect + TypePath + RegisterForReflection, TimerMode: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Virtual
where Virtual: Any + Send + Sync, Duration: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, f64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Transform
where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection, Quat: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BackgroundColor
where BackgroundColor: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BorderColor
where BorderColor: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for BorderRadius
where BorderRadius: Any + Send + Sync, Val: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CalculatedClip
where CalculatedClip: Any + Send + Sync, Rect: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for ContentSize
where ContentSize: Any + Send + Sync,

§

impl Reflect for GridPlacement
where GridPlacement: Any + Send + Sync, Option<NonZero<i16>>: FromReflect + TypePath + RegisterForReflection, Option<NonZero<u16>>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for GridTrack
where GridTrack: Any + Send + Sync, MinTrackSizingFunction: FromReflect + TypePath + RegisterForReflection, MaxTrackSizingFunction: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Node
where Node: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection, Vec2: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Outline
where Outline: Any + Send + Sync, Val: FromReflect + TypePath + RegisterForReflection, Color: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Overflow
where Overflow: Any + Send + Sync, OverflowAxis: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for RelativeCursorPosition
where RelativeCursorPosition: Any + Send + Sync, Rect: FromReflect + TypePath + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for RepeatedGridTrack
where RepeatedGridTrack: Any + Send + Sync, GridTrackRepetition: FromReflect + TypePath + RegisterForReflection, SmallVec<[GridTrack; 1]>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Style
where Style: Any + Send + Sync, Display: FromReflect + TypePath + RegisterForReflection, PositionType: FromReflect + TypePath + RegisterForReflection, Overflow: FromReflect + TypePath + RegisterForReflection, Direction: FromReflect + TypePath + RegisterForReflection, Val: FromReflect + TypePath + RegisterForReflection, Option<f32>: FromReflect + TypePath + RegisterForReflection, AlignItems: FromReflect + TypePath + RegisterForReflection, JustifyItems: FromReflect + TypePath + RegisterForReflection, AlignSelf: FromReflect + TypePath + RegisterForReflection, JustifySelf: FromReflect + TypePath + RegisterForReflection, AlignContent: FromReflect + TypePath + RegisterForReflection, JustifyContent: FromReflect + TypePath + RegisterForReflection, UiRect: FromReflect + TypePath + RegisterForReflection, FlexDirection: FromReflect + TypePath + RegisterForReflection, FlexWrap: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, GridAutoFlow: FromReflect + TypePath + RegisterForReflection, Vec<RepeatedGridTrack>: FromReflect + TypePath + RegisterForReflection, Vec<GridTrack>: FromReflect + TypePath + RegisterForReflection, GridPlacement: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for TargetCamera
where TargetCamera: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for UiImage
where UiImage: Any + Send + Sync, Color: FromReflect + TypePath + RegisterForReflection, Handle<Image>: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for UiRect
where UiRect: Any + Send + Sync, Val: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for UiScale
where UiScale: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Button
where Button: Any + Send + Sync,

§

impl Reflect for Label
where Label: Any + Send + Sync,

§

impl Reflect for TextFlags
where TextFlags: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for UiImageSize
where UiImageSize: Any + Send + Sync, UVec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for Duration
where Duration: Any + Send + Sync,

§

impl Reflect for Instant
where Instant: Any + Send + Sync,

§

impl Reflect for Cursor
where Cursor: Any + Send + Sync, CursorIcon: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, CursorGrabMode: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CursorEntered
where CursorEntered: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CursorLeft
where CursorLeft: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for CursorMoved
where CursorMoved: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, Vec2: FromReflect + TypePath + RegisterForReflection, Option<Vec2>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for EnabledButtons
where EnabledButtons: Any + Send + Sync, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for InternalWindowState
where InternalWindowState: Any + Send + Sync, Option<bool>: FromReflect + TypePath + RegisterForReflection, Option<DVec2>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for NormalizedWindowRef
where NormalizedWindowRef: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PrimaryWindow

§

impl Reflect for ReceivedCharacter
where ReceivedCharacter: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, SmolStr: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for RequestRedraw

§

impl Reflect for Window
where Window: Any + Send + Sync, Cursor: FromReflect + TypePath + RegisterForReflection, PresentMode: FromReflect + TypePath + RegisterForReflection, WindowMode: FromReflect + TypePath + RegisterForReflection, WindowPosition: FromReflect + TypePath + RegisterForReflection, WindowResolution: FromReflect + TypePath + RegisterForReflection, String: FromReflect + TypePath + RegisterForReflection, Option<String>: FromReflect + TypePath + RegisterForReflection, CompositeAlphaMode: FromReflect + TypePath + RegisterForReflection, WindowResizeConstraints: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection, EnabledButtons: FromReflect + TypePath + RegisterForReflection, WindowLevel: FromReflect + TypePath + RegisterForReflection, InternalWindowState: FromReflect + TypePath + RegisterForReflection, Vec2: FromReflect + TypePath + RegisterForReflection, Option<WindowTheme>: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowBackendScaleFactorChanged
where WindowBackendScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, f64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowCloseRequested
where WindowCloseRequested: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowClosed
where WindowClosed: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowCreated
where WindowCreated: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowDestroyed
where WindowDestroyed: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowFocused
where WindowFocused: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowMoved
where WindowMoved: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, IVec2: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowOccluded
where WindowOccluded: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowResizeConstraints
where WindowResizeConstraints: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowResized
where WindowResized: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowResolution
where WindowResolution: Any + Send + Sync, u32: FromReflect + TypePath + RegisterForReflection, Option<f32>: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowScaleFactorChanged
where WindowScaleFactorChanged: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, f64: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for WindowThemeChanged
where WindowThemeChanged: Any + Send + Sync, Entity: FromReflect + TypePath + RegisterForReflection, WindowTheme: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for DynamicArray

§

impl Reflect for DynamicEnum

§

impl Reflect for DynamicList

§

impl Reflect for DynamicMap

§

impl Reflect for DynamicStruct

§

impl Reflect for DynamicTuple

§

impl Reflect for DynamicTupleStruct

§

impl<'a> Reflect for AssetPath<'a>
where AssetPath<'a>: Any + Send + Sync,

§

impl<A> Reflect for AssetId<A>
where A: Asset + TypePath, AssetId<A>: Any + Send + Sync, AssetIndex: FromReflect + TypePath + RegisterForReflection, Uuid: FromReflect + TypePath + RegisterForReflection,

§

impl<A> Reflect for Handle<A>
where A: Asset + TypePath, Handle<A>: Any + Send + Sync, Arc<StrongHandle>: FromReflect + TypePath + RegisterForReflection, AssetId<A>: FromReflect + TypePath + RegisterForReflection,

§

impl<B, E> Reflect for ExtendedMaterial<B, E>
where B: Material + FromReflect + TypePath + RegisterForReflection, E: MaterialExtension + FromReflect + TypePath + RegisterForReflection, ExtendedMaterial<B, E>: Any + Send + Sync,

§

impl<K, V, S> Reflect for bevy::utils::hashbrown::HashMap<K, V, S>

§

impl<S> Reflect for NextState<S>
where S: States + TypePath, NextState<S>: Any + Send + Sync, Option<S>: FromReflect + TypePath + RegisterForReflection,

§

impl<S> Reflect for State<S>
where S: States + TypePath + FromReflect + RegisterForReflection, State<S>: Any + Send + Sync,

§

impl<T> Reflect for ButtonInput<T>
where T: Copy + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + RegisterForReflection,

§

impl<T> Reflect for Time<T>
where T: Default + TypePath + FromReflect + RegisterForReflection, Time<T>: Any + Send + Sync, Duration: FromReflect + TypePath + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, f64: FromReflect + TypePath + RegisterForReflection,

§

impl<T> Reflect for bevy::utils::hashbrown::HashSet<T>
where T: Hash + Eq + Clone + Send + Sync + TypePath, HashSet<T>: Any + Send + Sync,

§

impl<const N: usize> Reflect for Polygon<N>
where Polygon<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + RegisterForReflection,

§

impl<const N: usize> Reflect for Polyline2d<N>
where Polyline2d<N>: Any + Send + Sync, [Vec2; N]: FromReflect + TypePath + RegisterForReflection,

§

impl<const N: usize> Reflect for Polyline3d<N>
where Polyline3d<N>: Any + Send + Sync, [Vec3; N]: FromReflect + TypePath + RegisterForReflection,