Trait bevy::reflect::prelude::Reflect

pub trait Reflect: DynamicTypePath + Any + Send + Sync {
Show 20 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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>; 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 apply(&mut self, value: &(dyn Reflect + 'static)) { ... } 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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

Functions the same as the apply function but returns an error instead of panicking.

§Handling Errors

This function may leave self in a partially mutated state if a error was encountered on the way. consider maintaining a cloned instance of this data you can switch to if a error is encountered.

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 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
Examples found in repository?
examples/reflection/reflection.rs (line 81)
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);
}
More examples
Hide additional examples
examples/reflection/reflection_types.rs (line 120)
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]);
}
examples/reflection/dynamic_types.rs (line 99)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
fn main() {
    #[derive(Reflect, Default)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // But now let's "clone" our type using `Reflect::clone_value`.
    let cloned: Box<dyn Reflect> = reflected.clone_value();

    // If we try to downcast back to `Player`, we'll get an error.
    assert!(cloned.downcast_ref::<Player>().is_none());

    // Why is this?
    // Well the reason is that `Reflect::clone_value` actually creates a dynamic type.
    // Since `Player` is a struct, we actually get a `DynamicStruct` back.
    assert!(cloned.is::<DynamicStruct>());

    // This dynamic type is used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let ReflectRef::Struct(cloned_ref) = cloned.reflect_ref() else {
        panic!("expected struct")
    };
    let id = cloned_ref.field("id").unwrap().downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.downcast_ref::<DynamicStruct>().is_some());
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(reflect_identifiable
        .get(deserialized.as_reflect())
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `Reflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_reflect());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_reflect());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_reflect()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_reflect())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `Reflect::clone_value` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::default();
    my_dynamic_list.push(1u32);
    my_dynamic_list.push(2u32);
    my_dynamic_list.push(3u32);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list.as_reflect().represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list.as_reflect().represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_vec(vec![1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let mut dynamic_list = DynamicList::default();
        dynamic_list.push(1u32);
        dynamic_list.push(2u32);
        dynamic_list.push(3u32);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicMap`
    {
        let mut dynamic_map = DynamicMap::default();
        dynamic_map.insert("x", 1u32);
        dynamic_map.insert("y", 2u32);
        dynamic_map.insert("z", 3u32);

        let mut my_map: HashMap<&str, u32> = HashMap::new();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 5. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 6. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 7. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

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.

Examples found in repository?
examples/reflection/dynamic_types.rs (line 76)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
fn main() {
    #[derive(Reflect, Default)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // But now let's "clone" our type using `Reflect::clone_value`.
    let cloned: Box<dyn Reflect> = reflected.clone_value();

    // If we try to downcast back to `Player`, we'll get an error.
    assert!(cloned.downcast_ref::<Player>().is_none());

    // Why is this?
    // Well the reason is that `Reflect::clone_value` actually creates a dynamic type.
    // Since `Player` is a struct, we actually get a `DynamicStruct` back.
    assert!(cloned.is::<DynamicStruct>());

    // This dynamic type is used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let ReflectRef::Struct(cloned_ref) = cloned.reflect_ref() else {
        panic!("expected struct")
    };
    let id = cloned_ref.field("id").unwrap().downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.downcast_ref::<DynamicStruct>().is_some());
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(reflect_identifiable
        .get(deserialized.as_reflect())
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `Reflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_reflect());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_reflect());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_reflect()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_reflect())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `Reflect::clone_value` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::default();
    my_dynamic_list.push(1u32);
    my_dynamic_list.push(2u32);
    my_dynamic_list.push(3u32);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list.as_reflect().represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list.as_reflect().represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_vec(vec![1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let mut dynamic_list = DynamicList::default();
        dynamic_list.push(1u32);
        dynamic_list.push(2u32);
        dynamic_list.push(3u32);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicMap`
    {
        let mut dynamic_map = DynamicMap::default();
        dynamic_map.insert("x", 1u32);
        dynamic_map.insert("y", 2u32);
        dynamic_map.insert("z", 3u32);

        let mut my_map: HashMap<&str, u32> = HashMap::new();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 5. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 6. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 7. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

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.

Examples found in repository?
examples/reflection/dynamic_types.rs (line 52)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
fn main() {
    #[derive(Reflect, Default)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // But now let's "clone" our type using `Reflect::clone_value`.
    let cloned: Box<dyn Reflect> = reflected.clone_value();

    // If we try to downcast back to `Player`, we'll get an error.
    assert!(cloned.downcast_ref::<Player>().is_none());

    // Why is this?
    // Well the reason is that `Reflect::clone_value` actually creates a dynamic type.
    // Since `Player` is a struct, we actually get a `DynamicStruct` back.
    assert!(cloned.is::<DynamicStruct>());

    // This dynamic type is used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let ReflectRef::Struct(cloned_ref) = cloned.reflect_ref() else {
        panic!("expected struct")
    };
    let id = cloned_ref.field("id").unwrap().downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.downcast_ref::<DynamicStruct>().is_some());
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(reflect_identifiable
        .get(deserialized.as_reflect())
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `Reflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_reflect());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_reflect());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_reflect()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_reflect())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `Reflect::clone_value` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::default();
    my_dynamic_list.push(1u32);
    my_dynamic_list.push(2u32);
    my_dynamic_list.push(3u32);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list.as_reflect().represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list.as_reflect().represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_vec(vec![1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let mut dynamic_list = DynamicList::default();
        dynamic_list.push(1u32);
        dynamic_list.push(2u32);
        dynamic_list.push(3u32);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicMap`
    {
        let mut dynamic_map = DynamicMap::default();
        dynamic_map.insert("x", 1u32);
        dynamic_map.insert("y", 2u32);
        dynamic_map.insert("z", 3u32);

        let mut my_map: HashMap<&str, u32> = HashMap::new();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 5. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 6. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 7. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

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);
}
More examples
Hide additional examples
examples/reflection/custom_attributes.rs (line 64)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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
fn main() {
    // Bevy supports statically registering custom attribute data on reflected types,
    // which can then be accessed at runtime via the type's `TypeInfo`.
    // Attributes are registered using the `#[reflect(@...)]` syntax,
    // where the `...` is any expression that resolves to a value which implements `Reflect`.
    // Note that these attributes are stored based on their type:
    // if two attributes have the same type, the second one will overwrite the first.

    // Here is an example of registering custom attributes on a type:
    #[derive(Reflect)]
    struct Slider {
        #[reflect(@RangeInclusive::<f32>::new(0.0, 1.0))]
        // Alternatively, we could have used the `0.0..=1.0` syntax,
        // but remember to ensure the type is the one you want!
        #[reflect(@0.0..=1.0_f32)]
        value: f32,
    }

    // Now, we can access the custom attributes at runtime:
    let TypeInfo::Struct(type_info) = Slider::type_info() else {
        panic!("expected struct");
    };

    let field = type_info.field("value").unwrap();

    let range = field.get_attribute::<RangeInclusive<f32>>().unwrap();
    assert_eq!(*range, 0.0..=1.0);

    // And remember that our attributes can be any type that implements `Reflect`:
    #[derive(Reflect)]
    struct Required;

    #[derive(Reflect, PartialEq, Debug)]
    struct Tooltip(String);

    impl Tooltip {
        fn new(text: &str) -> Self {
            Self(text.to_string())
        }
    }

    #[derive(Reflect)]
    #[reflect(@Required, @Tooltip::new("An ID is required!"))]
    struct Id(u8);

    let TypeInfo::TupleStruct(type_info) = Id::type_info() else {
        panic!("expected struct");
    };

    // We can check if an attribute simply exists on our type:
    assert!(type_info.has_attribute::<Required>());

    // We can also get attribute data dynamically:
    let some_type_id = TypeId::of::<Tooltip>();

    let tooltip: &dyn Reflect = type_info.get_attribute_by_id(some_type_id).unwrap();
    assert_eq!(
        tooltip.downcast_ref::<Tooltip>(),
        Some(&Tooltip::new("An ID is required!"))
    );

    // And again, attributes of the same type will overwrite each other:
    #[derive(Reflect)]
    enum Status {
        // This will result in `false` being stored:
        #[reflect(@true)]
        #[reflect(@false)]
        Disabled,
        // This will result in `true` being stored:
        #[reflect(@false)]
        #[reflect(@true)]
        Enabled,
    }

    let TypeInfo::Enum(type_info) = Status::type_info() else {
        panic!("expected enum");
    };

    let disabled = type_info.variant("Disabled").unwrap();
    assert!(!disabled.get_attribute::<bool>().unwrap());

    let enabled = type_info.variant("Enabled").unwrap();
    assert!(enabled.get_attribute::<bool>().unwrap());
}
examples/reflection/dynamic_types.rs (line 41)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
fn main() {
    #[derive(Reflect, Default)]
    #[reflect(Identifiable, Default)]
    struct Player {
        id: u32,
    }

    #[reflect_trait]
    trait Identifiable {
        fn id(&self) -> u32;
    }

    impl Identifiable for Player {
        fn id(&self) -> u32 {
            self.id
        }
    }

    // Normally, when instantiating a type, you get back exactly that type.
    // This is because the type is known at compile time.
    // We call this the "concrete" or "canonical" type.
    let player: Player = Player { id: 123 };

    // When working with reflected types, however, we often "erase" this type information
    // using the `Reflect` trait object.
    // The underlying type is still the same (in this case, `Player`),
    // but now we've hidden that information from the compiler.
    let reflected: Box<dyn Reflect> = Box::new(player);

    // Because it's the same type under the hood, we can still downcast it back to the original type.
    assert!(reflected.downcast_ref::<Player>().is_some());

    // But now let's "clone" our type using `Reflect::clone_value`.
    let cloned: Box<dyn Reflect> = reflected.clone_value();

    // If we try to downcast back to `Player`, we'll get an error.
    assert!(cloned.downcast_ref::<Player>().is_none());

    // Why is this?
    // Well the reason is that `Reflect::clone_value` actually creates a dynamic type.
    // Since `Player` is a struct, we actually get a `DynamicStruct` back.
    assert!(cloned.is::<DynamicStruct>());

    // This dynamic type is used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let ReflectRef::Struct(cloned_ref) = cloned.reflect_ref() else {
        panic!("expected struct")
    };
    let id = cloned_ref.field("id").unwrap().downcast_ref::<u32>();
    assert_eq!(id, Some(&123));

    // It also enables us to create a representation of a type without having compile-time
    // access to the actual type. This is how the reflection deserializers work.
    // They generally can't know how to construct a type ahead of time,
    // so they instead build and return these dynamic representations.
    let input = "(id: 123)";
    let mut registry = TypeRegistry::default();
    registry.register::<Player>();
    let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
    let deserialized = TypedReflectDeserializer::new(registration, &registry)
        .deserialize(&mut ron::Deserializer::from_str(input).unwrap())
        .unwrap();

    // Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
    assert!(deserialized.downcast_ref::<DynamicStruct>().is_some());
    assert!(deserialized.represents::<Player>());

    // And while this does allow us to access the fields and structure of the type,
    // there may be instances where we need the actual type.
    // For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
    // we can't use the `DynamicStruct` proxy.
    let reflect_identifiable = registration
        .data::<ReflectIdentifiable>()
        .expect("`ReflectIdentifiable` should be registered");

    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(reflect_identifiable
        .get(deserialized.as_reflect())
        .is_none());

    // So how can we go from a dynamic type to a concrete type?
    // There are two ways:

    // 1. Using `Reflect::apply`.
    {
        // If you know the type at compile time, you can construct a new value and apply the dynamic
        // value to it.
        let mut value = Player::default();
        value.apply(deserialized.as_reflect());
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you need a dynamic way of constructing
        // an instance of the type. One such way is to use the `ReflectDefault` type data.
        let reflect_default = registration
            .data::<ReflectDefault>()
            .expect("`ReflectDefault` should be registered");

        let mut value: Box<dyn Reflect> = reflect_default.default();
        value.apply(deserialized.as_reflect());

        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // 2. Using `FromReflect`
    {
        // If you know the type at compile time, you can use the `FromReflect` trait to convert the
        // dynamic value into the concrete type directly.
        let value: Player = Player::from_reflect(deserialized.as_reflect()).unwrap();
        assert_eq!(value.id, 123);

        // If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
        // to perform the conversion dynamically.
        let reflect_from_reflect = registration
            .data::<ReflectFromReflect>()
            .expect("`ReflectFromReflect` should be registered");

        let value: Box<dyn Reflect> = reflect_from_reflect
            .from_reflect(deserialized.as_reflect())
            .unwrap();
        let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
        assert_eq!(identifiable.id(), 123);
    }

    // Lastly, while dynamic types are commonly generated via reflection methods like
    // `Reflect::clone_value` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::default();
    my_dynamic_list.push(1u32);
    my_dynamic_list.push(2u32);
    my_dynamic_list.push(3u32);

    // This is useful when you just need to apply some subset of changes to a type.
    let mut my_list: Vec<u32> = Vec::new();
    my_list.apply(&my_dynamic_list);
    assert_eq!(my_list, vec![1, 2, 3]);

    // And if you want it to actually proxy a type, you can configure it to do that as well:
    assert!(!my_dynamic_list.as_reflect().represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list.as_reflect().represents::<Vec<u32>>());

    // ============================= REFERENCE ============================= //
    // For reference, here are all the available dynamic types:

    // 1. `DynamicTuple`
    {
        let mut dynamic_tuple = DynamicTuple::default();
        dynamic_tuple.insert(1u32);
        dynamic_tuple.insert(2u32);
        dynamic_tuple.insert(3u32);

        let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
        my_tuple.apply(&dynamic_tuple);
        assert_eq!(my_tuple, (1, 2, 3));
    }

    // 2. `DynamicArray`
    {
        let dynamic_array = DynamicArray::from_vec(vec![1u32, 2u32, 3u32]);

        let mut my_array = [0u32; 3];
        my_array.apply(&dynamic_array);
        assert_eq!(my_array, [1, 2, 3]);
    }

    // 3. `DynamicList`
    {
        let mut dynamic_list = DynamicList::default();
        dynamic_list.push(1u32);
        dynamic_list.push(2u32);
        dynamic_list.push(3u32);

        let mut my_list: Vec<u32> = Vec::new();
        my_list.apply(&dynamic_list);
        assert_eq!(my_list, vec![1, 2, 3]);
    }

    // 4. `DynamicMap`
    {
        let mut dynamic_map = DynamicMap::default();
        dynamic_map.insert("x", 1u32);
        dynamic_map.insert("y", 2u32);
        dynamic_map.insert("z", 3u32);

        let mut my_map: HashMap<&str, u32> = HashMap::new();
        my_map.apply(&dynamic_map);
        assert_eq!(my_map.get("x"), Some(&1));
        assert_eq!(my_map.get("y"), Some(&2));
        assert_eq!(my_map.get("z"), Some(&3));
    }

    // 5. `DynamicStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyStruct {
            x: u32,
            y: u32,
            z: u32,
        }

        let mut dynamic_struct = DynamicStruct::default();
        dynamic_struct.insert("x", 1u32);
        dynamic_struct.insert("y", 2u32);
        dynamic_struct.insert("z", 3u32);

        let mut my_struct = MyStruct::default();
        my_struct.apply(&dynamic_struct);
        assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
    }

    // 6. `DynamicTupleStruct`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        struct MyTupleStruct(u32, u32, u32);

        let mut dynamic_tuple_struct = DynamicTupleStruct::default();
        dynamic_tuple_struct.insert(1u32);
        dynamic_tuple_struct.insert(2u32);
        dynamic_tuple_struct.insert(3u32);

        let mut my_tuple_struct = MyTupleStruct::default();
        my_tuple_struct.apply(&dynamic_tuple_struct);
        assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
    }

    // 7. `DynamicEnum`
    {
        #[derive(Reflect, Default, Debug, PartialEq)]
        enum MyEnum {
            #[default]
            Empty,
            Xyz(u32, u32, u32),
        }

        let mut values = DynamicTuple::default();
        values.insert(1u32);
        values.insert(2u32);
        values.insert(3u32);

        let dynamic_variant = DynamicVariant::Tuple(values);
        let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);

        let mut my_enum = MyEnum::default();
        my_enum.apply(&dynamic_enum);
        assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
    }
}

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, __value_param: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 Result<T, E>: Any + Send + Sync, T: TypePath + FromReflect + RegisterForReflection, E: TypePath + FromReflect + RegisterForReflection,

§

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 set( &mut self, __value_param: Box<dyn Reflect>, ) -> Result<(), Box<dyn Reflect>>

§

fn try_apply( &mut self, __value_param: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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

§

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

§

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

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

§

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 SmaaPreset
where SmaaPreset: 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 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 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 MouseScrollUnit

§

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 KeyCode
where KeyCode: Any + Send + Sync, NativeKeyCode: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for MouseButton
where MouseButton: Any + Send + Sync, u16: FromReflect + TypePath + RegisterForReflection,

§

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 CompassOctant

§

impl Reflect for CompassQuadrant

§

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 UvChannel
where UvChannel: Any + Send + Sync,

§

impl Reflect for PointerButton

§

impl Reflect for PointerId
where PointerId: Any + Send + Sync, u64: FromReflect + TypePath + RegisterForReflection, Uuid: FromReflect + TypePath + RegisterForReflection,

§

impl Reflect for PressDirection

§

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 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 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 Msaa
where Msaa: Any + Send + Sync,

§

impl Reflect for Projection
where Projection: Any + Send + Sync, PerspectiveProjection: FromReflect + TypePath + RegisterForReflection, OrthographicProjection: FromReflect + TypePath + RegisterForReflection,

§

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 AppLifecycle

§

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, AppLifecycle: 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, PinchGesture: FromReflect + TypePath + RegisterForReflection, RotationGesture: FromReflect + TypePath + RegisterForReflection, DoubleTapGesture: FromReflect + TypePath + RegisterForReflection, PanGesture: FromReflect + TypePath + RegisterForReflection, TouchInput: FromReflect + TypePath + RegisterForReflection, KeyboardInput: FromReflect + TypePath + RegisterForReflection, KeyboardFocusLost: 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