Trait PartialReflect 

pub trait PartialReflect:
    DynamicTypePath
    + Send
    + Sync
    + 'static {
    // Required methods
    fn get_represented_type_info(&self) -> Option<&'static TypeInfo>;
    fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>;
    fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static);
    fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static);
    fn try_into_reflect(
        self: Box<Self>,
    ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>;
    fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>;
    fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>;
    fn try_apply(
        &mut self,
        value: &(dyn PartialReflect + 'static),
    ) -> Result<(), ApplyError>;
    fn reflect_ref(&self) -> ReflectRef<'_>;
    fn reflect_mut(&mut self) -> ReflectMut<'_>;
    fn reflect_owned(self: Box<Self>) -> ReflectOwned;

    // Provided methods
    fn apply(&mut self, value: &(dyn PartialReflect + 'static)) { ... }
    fn reflect_kind(&self) -> ReflectKind { ... }
    fn to_dynamic(&self) -> Box<dyn PartialReflect> { ... }
    fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError> { ... }
    fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
       where T: 'static,
             Self: Sized + TypePath { ... }
    fn reflect_hash(&self) -> Option<u64> { ... }
    fn reflect_partial_eq(
        &self,
        _value: &(dyn PartialReflect + 'static),
    ) -> Option<bool> { ... }
    fn reflect_partial_cmp(
        &self,
        _value: &(dyn PartialReflect + 'static),
    ) -> Option<Ordering> { ... }
    fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error> { ... }
    fn is_dynamic(&self) -> bool { ... }
}

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

This is a supertrait of Reflect, meaning any type which implements Reflect implements PartialReflect by definition.

It’s recommended to use the derive macro for Reflect rather than manually implementing this trait. Doing so will automatically implement this trait as well as 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_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

This is useful for coercing trait objects.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

This is useful for coercing trait objects.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

This is useful for coercing trait objects.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn try_apply( &mut self, value: &(dyn PartialReflect + '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 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.

Provided Methods

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

Applies a reflected value to this value.

If Self implements a reflection subtrait, then the semantics of this method are as follows:

• If Self 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 Self 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 Self 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 Self 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 Self 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, and keys from self which are not present in value are removed.
• If Self is a Set, then each element of value is applied to the corresponding element of Self. If an element of value does not exist in Self then it is cloned and inserted. If an element from self is not present in value then it is removed.
• If Self is none of these, then value is downcast to Self, cloned, and assigned to self.

Note that Reflect must be implemented manually for Lists, Maps, and Sets 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, maps, and sets, use the list_apply, map_apply, and set_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 Self (e.g. if Self is a List, while value is a Struct).
• If Self is any complex type and the corresponding fields or elements of self and value are not of the same type.
• If Self is an opaque type and value cannot be downcast to Self

Examples found in repository

examples/reflection/reflection.rs (line 87)

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 PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_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 PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // 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);
}

examples/reflection/reflection_types.rs (line 141)

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(_) => {}
        // `Set` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "set" operations on your type, such as getting / inserting by value.
        // Set is automatically implemented for relevant core types like HashSet<T>
        ReflectRef::Set(_) => {}
        // `Function` is a special trait that can be manually implemented (instead of deriving Reflect).
        // This exposes "function" operations on your type, such as calling it with arguments.
        // This trait is automatically implemented for types like DynamicFunction.
        // This variant only exists if the `reflect_functions` feature is enabled.
        #[cfg(feature = "reflect_functions")]
        ReflectRef::Function(_) => {}
        // `Opaque` types do not implement any of the other traits above. They are simply a Reflect
        // implementation. Opaque is implemented for opaque types like String and Instant,
        // but also include primitive types like i32, usize, and f32 (despite not technically being opaque).
        ReflectRef::Opaque(_) => {}
        #[expect(
            clippy::allow_attributes,
            reason = "`unreachable_patterns` is not always linted"
        )]
        #[allow(
            unreachable_patterns,
            reason = "This example cannot always detect when `bevy_reflect/functions` is enabled."
        )]
        _ => {}
    }

    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]);

    // reference types defined above that are only used to demonstrate reflect
    // derive functionality:
    _ = || -> (A, B, C, D, E, F) { unreachable!() };
}

examples/reflection/dynamic_types.rs (line 116)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[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.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // 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());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_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.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");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

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

    // 1. Using `PartialReflect::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_ref());
        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_ref());

        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_ref()).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_ref())
            .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
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 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_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_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_iter([1u32, 2u32, 3u32]);

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

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

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

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        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));
    }

    // 6. `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 });
    }

    // 7. `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));
    }

    // 8. `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 to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

For example, a List type will internally invoke List::to_dynamic_list, returning DynamicList. A Struct type will invoke Struct::to_dynamic_struct, returning DynamicStruct. And so on.

If the kind is opaque, then the value will attempt to be cloned directly via reflect_clone, since opaque types do not have any standard dynamic representation.

To attempt to clone the value directly such that it returns a concrete instance of this type, use reflect_clone.

Panics

This method will panic if the kind is opaque and the call to reflect_clone fails.

Example

let value = (1, true, 3.14);
let dynamic_value = value.to_dynamic();
assert!(dynamic_value.is_dynamic())

Examples found in repository

examples/reflection/dynamic_types.rs (line 63)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[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.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // 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());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_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.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");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

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

    // 1. Using `PartialReflect::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_ref());
        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_ref());

        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_ref()).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_ref())
            .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
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 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_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_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_iter([1u32, 2u32, 3u32]);

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

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

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

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        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));
    }

    // 6. `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 });
    }

    // 7. `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));
    }

    // 8. `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_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

Unlike to_dynamic, which generally returns a dynamic representation of Self, this method attempts create a clone of Self directly, if possible.

If the clone cannot be performed, an appropriate ReflectCloneError is returned.

Example

let value = (1, true, 3.14);
let cloned = value.reflect_clone().unwrap();
assert!(cloned.is::<(i32, bool, f64)>())

Examples found in repository

examples/reflection/dynamic_types.rs (line 56)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[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.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // 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());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_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.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");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

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

    // 1. Using `PartialReflect::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_ref());
        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_ref());

        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_ref()).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_ref())
            .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
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 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_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_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_iter([1u32, 2u32, 3u32]);

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

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

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

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        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));
    }

    // 6. `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 });
    }

    // 7. `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));
    }

    // 8. `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_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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 PartialReflect + '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 115)

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 PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_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 PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // 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 reflect_partial_cmp( &self, _value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

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 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.

Examples found in repository

examples/reflection/dynamic_types.rs (line 64)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[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.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // 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());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_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.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");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

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

    // 1. Using `PartialReflect::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_ref());
        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_ref());

        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_ref()).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_ref())
            .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
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 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_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_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_iter([1u32, 2u32, 3u32]);

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

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

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

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        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));
    }

    // 6. `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 });
    }

    // 7. `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));
    }

    // 8. `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));
    }
}

Implementations

impl dyn PartialReflect

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

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[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.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // 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());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_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.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");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

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

    // 1. Using `PartialReflect::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_ref());
        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_ref());

        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_ref()).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_ref())
            .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
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 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_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_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_iter([1u32, 2u32, 3u32]);

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

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

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

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        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));
    }

    // 6. `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 });
    }

    // 7. `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));
    }

    // 8. `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 try_downcast<T>( self: Box<dyn PartialReflect>, ) -> Result<Box<T>, Box<dyn PartialReflect>>

where T: Any,

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

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

For remote types, T should be the type itself rather than the wrapper type.

pub fn try_take<T>( self: Box<dyn PartialReflect>, ) -> Result<T, Box<dyn PartialReflect>>

where T: Any,

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

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

For remote types, T should be the type itself rather than the wrapper type.

Examples found in repository

examples/reflection/function_reflection.rs (line 58)

fn main() {
    // There are times when it may be helpful to store a function away for later.
    // In Rust, we can do this by storing either a function pointer or a function trait object.
    // For example, say we wanted to store the following function:
    fn add(left: i32, right: i32) -> i32 {
        left + right
    }

    // We could store it as either of the following:
    let fn_pointer: fn(i32, i32) -> i32 = add;
    let fn_trait_object: Box<dyn Fn(i32, i32) -> i32> = Box::new(add);

    // And we can call them like so:
    let result = fn_pointer(2, 2);
    assert_eq!(result, 4);
    let result = fn_trait_object(2, 2);
    assert_eq!(result, 4);

    // However, you'll notice that we have to know the types of the arguments and return value at compile time.
    // This means there's not really a way to store or call these functions dynamically at runtime.
    // Luckily, Bevy's reflection crate comes with a set of tools for doing just that!
    // We do this by first converting our function into the reflection-based `DynamicFunction` type
    // using the `IntoFunction` trait.
    let function: DynamicFunction<'static> = dbg!(add.into_function());

    // This time, you'll notice that `DynamicFunction` doesn't take any information about the function's arguments or return value.
    // This is because `DynamicFunction` checks the types of the arguments and return value at runtime.
    // Now we can generate a list of arguments:
    let args: ArgList = dbg!(ArgList::new().with_owned(2_i32).with_owned(2_i32));

    // And finally, we can call the function.
    // This returns a `Result` indicating whether the function was called successfully.
    // For now, we'll just unwrap it to get our `Return` value,
    // which is an enum containing the function's return value.
    let return_value: Return = dbg!(function.call(args).unwrap());

    // The `Return` value can be pattern matched or unwrapped to get the underlying reflection data.
    // For the sake of brevity, we'll just unwrap it here and downcast it to the expected type of `i32`.
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 4);

    // The same can also be done for closures that capture references to their environment.
    // Closures that capture their environment immutably can be converted into a `DynamicFunction`
    // using the `IntoFunction` trait.
    let minimum = 5;
    let clamp = |value: i32| value.max(minimum);

    let function: DynamicFunction = dbg!(clamp.into_function());
    let args = dbg!(ArgList::new().with_owned(2_i32));
    let return_value = dbg!(function.call(args).unwrap());
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 5);

    // We can also handle closures that capture their environment mutably
    // using the `IntoFunctionMut` trait.
    let mut count = 0;
    let increment = |amount: i32| count += amount;

    let closure: DynamicFunctionMut = dbg!(increment.into_function_mut());
    let args = dbg!(ArgList::new().with_owned(5_i32));

    // Because `DynamicFunctionMut` mutably borrows `total`,
    // it will need to be dropped before `total` can be accessed again.
    // This can be done manually with `drop(closure)` or by using the `DynamicFunctionMut::call_once` method.
    dbg!(closure.call_once(args).unwrap());
    assert_eq!(count, 5);

    // Generic functions can also be converted into a `DynamicFunction`,
    // however, they will need to be manually monomorphized first.
    fn stringify<T: ToString>(value: T) -> String {
        value.to_string()
    }

    // We have to manually specify the concrete generic type we want to use.
    let function = stringify::<i32>.into_function();

    let args = ArgList::new().with_owned(123_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "123");

    // To make things a little easier, we can also "overload" functions.
    // This makes it so that a single `DynamicFunction` can represent multiple functions,
    // and the correct one is chosen based on the types of the arguments.
    // Each function overload must have a unique argument signature.
    let function = stringify::<i32>
        .into_function()
        .with_overload(stringify::<f32>);

    // Now our `function` accepts both `i32` and `f32` arguments.
    let args = ArgList::new().with_owned(1.23_f32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "1.23");

    // Function overloading even allows us to have a variable number of arguments.
    let function = (|| 0)
        .into_function()
        .with_overload(|a: i32| a)
        .with_overload(|a: i32, b: i32| a + b)
        .with_overload(|a: i32, b: i32, c: i32| a + b + c);

    let args = ArgList::new()
        .with_owned(1_i32)
        .with_owned(2_i32)
        .with_owned(3_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 6);

    // As stated earlier, `IntoFunction` works for many kinds of simple functions.
    // Functions with non-reflectable arguments or return values may not be able to be converted.
    // Generic functions are also not supported (unless manually monomorphized like `foo::<i32>.into_function()`).
    // Additionally, the lifetime of the return value is tied to the lifetime of the first argument.
    // However, this means that many methods (i.e. functions with a `self` parameter) are also supported:
    #[derive(Reflect, Default)]
    struct Data {
        value: String,
    }

    impl Data {
        fn set_value(&mut self, value: String) {
            self.value = value;
        }

        // Note that only `&'static str` implements `Reflect`.
        // To get around this limitation we can use `&String` instead.
        fn get_value(&self) -> &String {
            &self.value
        }
    }

    let mut data = Data::default();

    let set_value = dbg!(Data::set_value.into_function());
    let args = dbg!(ArgList::new().with_mut(&mut data)).with_owned(String::from("Hello, world!"));
    dbg!(set_value.call(args).unwrap());
    assert_eq!(data.value, "Hello, world!");

    let get_value = dbg!(Data::get_value.into_function());
    let args = dbg!(ArgList::new().with_ref(&data));
    let return_value = dbg!(get_value.call(args).unwrap());
    let value: &dyn PartialReflect = return_value.unwrap_ref();
    assert_eq!(value.try_downcast_ref::<String>().unwrap(), "Hello, world!");

    // For more complex use cases, you can always create a custom `DynamicFunction` manually.
    // This is useful for functions that can't be converted via the `IntoFunction` trait.
    // For example, this function doesn't implement `IntoFunction` due to the fact that
    // the lifetime of the return value is not tied to the lifetime of the first argument.
    fn get_or_insert(value: i32, container: &mut Option<i32>) -> &i32 {
        if container.is_none() {
            *container = Some(value);
        }

        container.as_ref().unwrap()
    }

    let get_or_insert_function = dbg!(DynamicFunction::new(
        |mut args: ArgList| -> FunctionResult {
            // The `ArgList` contains the arguments in the order they were pushed.
            // The `DynamicFunction` will validate that the list contains
            // exactly the number of arguments we expect.
            // We can retrieve them out in order (note that this modifies the `ArgList`):
            let value = args.take::<i32>()?;
            let container = args.take::<&mut Option<i32>>()?;

            // We could have also done the following to make use of type inference:
            // let value = args.take_owned()?;
            // let container = args.take_mut()?;

            Ok(Return::Ref(get_or_insert(value, container)))
        },
        // Functions can be either anonymous or named.
        // It's good practice, though, to try and name your functions whenever possible.
        // This makes it easier to debug and is also required for function registration.
        // We can either give it a custom name or use the function's type name as
        // derived from `std::any::type_name_of_val`.
        SignatureInfo::named(std::any::type_name_of_val(&get_or_insert))
            // We can always change the name if needed.
            // It's a good idea to also ensure that the name is unique,
            // such as by using its type name or by prefixing it with your crate name.
            .with_name("my_crate::get_or_insert")
            // Since our function takes arguments, we should provide that argument information.
            // This is used to validate arguments when calling the function.
            // And it aids consumers of the function with their own validation and debugging.
            // Arguments should be provided in the order they are defined in the function.
            .with_arg::<i32>("value")
            .with_arg::<&mut Option<i32>>("container")
            // We can provide return information as well.
            .with_return::<&i32>(),
    ));

    let mut container: Option<i32> = None;

    let args = dbg!(ArgList::new().with_owned(5_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));

    let args = dbg!(ArgList::new().with_owned(500_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));
}

pub fn try_downcast_ref<T>(&self) -> Option<&T>

where T: Any,

Downcasts the value to type T by reference.

If the underlying value does not implement Reflect or is not of type T, returns None.

For remote types, T should be the type itself rather than the wrapper type.

Examples found in repository

examples/reflection/reflection_types.rs (line 49)

#[reflect(Hash, PartialEq, Clone)]
pub struct E {
    x: usize,
}

/// By default, deriving with Reflect assumes the type is either a "struct" or an "enum".
///
/// You can tell reflect to treat your type instead as an "opaque type" by using the `#[reflect(opaque)]`.
/// It is generally a good idea to implement (and reflect) the `PartialEq` and `Clone` (optionally also `Serialize` and `Deserialize`)
/// traits on opaque types to ensure that these values behave as expected when nested in other reflected types.
#[derive(Reflect, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[reflect(opaque)]
#[reflect(PartialEq

examples/reflection/reflection.rs (line 78)

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 PartialReflect` value of a field like this
    let field = value.field("a").unwrap();

    // But values introspected via `PartialReflect` will not return `dyn Reflect` trait objects
    // (even if the containing type does implement `Reflect`), so we need to convert them:
    let fully_reflected_field = field.try_as_reflect().unwrap();

    // Now, you can downcast your `Reflect` value like this:
    assert_eq!(*fully_reflected_field.downcast_ref::<usize>().unwrap(), 2);

    // For this specific case, we also support the shortcut `try_downcast_ref`:
    assert_eq!(*field.try_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 PartialReflect>` value.
    // Generally, deserializing a value will return the "dynamic" variant of a type.
    // For example, deserializing a struct will return the DynamicStruct type.
    // "Opaque types" will be deserialized as themselves.
    assert_eq!(
        reflect_value.reflect_type_path(),
        DynamicStruct::type_path(),
    );

    // 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);
}

examples/reflection/function_reflection.rs (line 162)

fn main() {
    // There are times when it may be helpful to store a function away for later.
    // In Rust, we can do this by storing either a function pointer or a function trait object.
    // For example, say we wanted to store the following function:
    fn add(left: i32, right: i32) -> i32 {
        left + right
    }

    // We could store it as either of the following:
    let fn_pointer: fn(i32, i32) -> i32 = add;
    let fn_trait_object: Box<dyn Fn(i32, i32) -> i32> = Box::new(add);

    // And we can call them like so:
    let result = fn_pointer(2, 2);
    assert_eq!(result, 4);
    let result = fn_trait_object(2, 2);
    assert_eq!(result, 4);

    // However, you'll notice that we have to know the types of the arguments and return value at compile time.
    // This means there's not really a way to store or call these functions dynamically at runtime.
    // Luckily, Bevy's reflection crate comes with a set of tools for doing just that!
    // We do this by first converting our function into the reflection-based `DynamicFunction` type
    // using the `IntoFunction` trait.
    let function: DynamicFunction<'static> = dbg!(add.into_function());

    // This time, you'll notice that `DynamicFunction` doesn't take any information about the function's arguments or return value.
    // This is because `DynamicFunction` checks the types of the arguments and return value at runtime.
    // Now we can generate a list of arguments:
    let args: ArgList = dbg!(ArgList::new().with_owned(2_i32).with_owned(2_i32));

    // And finally, we can call the function.
    // This returns a `Result` indicating whether the function was called successfully.
    // For now, we'll just unwrap it to get our `Return` value,
    // which is an enum containing the function's return value.
    let return_value: Return = dbg!(function.call(args).unwrap());

    // The `Return` value can be pattern matched or unwrapped to get the underlying reflection data.
    // For the sake of brevity, we'll just unwrap it here and downcast it to the expected type of `i32`.
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 4);

    // The same can also be done for closures that capture references to their environment.
    // Closures that capture their environment immutably can be converted into a `DynamicFunction`
    // using the `IntoFunction` trait.
    let minimum = 5;
    let clamp = |value: i32| value.max(minimum);

    let function: DynamicFunction = dbg!(clamp.into_function());
    let args = dbg!(ArgList::new().with_owned(2_i32));
    let return_value = dbg!(function.call(args).unwrap());
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 5);

    // We can also handle closures that capture their environment mutably
    // using the `IntoFunctionMut` trait.
    let mut count = 0;
    let increment = |amount: i32| count += amount;

    let closure: DynamicFunctionMut = dbg!(increment.into_function_mut());
    let args = dbg!(ArgList::new().with_owned(5_i32));

    // Because `DynamicFunctionMut` mutably borrows `total`,
    // it will need to be dropped before `total` can be accessed again.
    // This can be done manually with `drop(closure)` or by using the `DynamicFunctionMut::call_once` method.
    dbg!(closure.call_once(args).unwrap());
    assert_eq!(count, 5);

    // Generic functions can also be converted into a `DynamicFunction`,
    // however, they will need to be manually monomorphized first.
    fn stringify<T: ToString>(value: T) -> String {
        value.to_string()
    }

    // We have to manually specify the concrete generic type we want to use.
    let function = stringify::<i32>.into_function();

    let args = ArgList::new().with_owned(123_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "123");

    // To make things a little easier, we can also "overload" functions.
    // This makes it so that a single `DynamicFunction` can represent multiple functions,
    // and the correct one is chosen based on the types of the arguments.
    // Each function overload must have a unique argument signature.
    let function = stringify::<i32>
        .into_function()
        .with_overload(stringify::<f32>);

    // Now our `function` accepts both `i32` and `f32` arguments.
    let args = ArgList::new().with_owned(1.23_f32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<String>().unwrap(), "1.23");

    // Function overloading even allows us to have a variable number of arguments.
    let function = (|| 0)
        .into_function()
        .with_overload(|a: i32| a)
        .with_overload(|a: i32, b: i32| a + b)
        .with_overload(|a: i32, b: i32, c: i32| a + b + c);

    let args = ArgList::new()
        .with_owned(1_i32)
        .with_owned(2_i32)
        .with_owned(3_i32);
    let return_value = function.call(args).unwrap();
    let value: Box<dyn PartialReflect> = return_value.unwrap_owned();
    assert_eq!(value.try_take::<i32>().unwrap(), 6);

    // As stated earlier, `IntoFunction` works for many kinds of simple functions.
    // Functions with non-reflectable arguments or return values may not be able to be converted.
    // Generic functions are also not supported (unless manually monomorphized like `foo::<i32>.into_function()`).
    // Additionally, the lifetime of the return value is tied to the lifetime of the first argument.
    // However, this means that many methods (i.e. functions with a `self` parameter) are also supported:
    #[derive(Reflect, Default)]
    struct Data {
        value: String,
    }

    impl Data {
        fn set_value(&mut self, value: String) {
            self.value = value;
        }

        // Note that only `&'static str` implements `Reflect`.
        // To get around this limitation we can use `&String` instead.
        fn get_value(&self) -> &String {
            &self.value
        }
    }

    let mut data = Data::default();

    let set_value = dbg!(Data::set_value.into_function());
    let args = dbg!(ArgList::new().with_mut(&mut data)).with_owned(String::from("Hello, world!"));
    dbg!(set_value.call(args).unwrap());
    assert_eq!(data.value, "Hello, world!");

    let get_value = dbg!(Data::get_value.into_function());
    let args = dbg!(ArgList::new().with_ref(&data));
    let return_value = dbg!(get_value.call(args).unwrap());
    let value: &dyn PartialReflect = return_value.unwrap_ref();
    assert_eq!(value.try_downcast_ref::<String>().unwrap(), "Hello, world!");

    // For more complex use cases, you can always create a custom `DynamicFunction` manually.
    // This is useful for functions that can't be converted via the `IntoFunction` trait.
    // For example, this function doesn't implement `IntoFunction` due to the fact that
    // the lifetime of the return value is not tied to the lifetime of the first argument.
    fn get_or_insert(value: i32, container: &mut Option<i32>) -> &i32 {
        if container.is_none() {
            *container = Some(value);
        }

        container.as_ref().unwrap()
    }

    let get_or_insert_function = dbg!(DynamicFunction::new(
        |mut args: ArgList| -> FunctionResult {
            // The `ArgList` contains the arguments in the order they were pushed.
            // The `DynamicFunction` will validate that the list contains
            // exactly the number of arguments we expect.
            // We can retrieve them out in order (note that this modifies the `ArgList`):
            let value = args.take::<i32>()?;
            let container = args.take::<&mut Option<i32>>()?;

            // We could have also done the following to make use of type inference:
            // let value = args.take_owned()?;
            // let container = args.take_mut()?;

            Ok(Return::Ref(get_or_insert(value, container)))
        },
        // Functions can be either anonymous or named.
        // It's good practice, though, to try and name your functions whenever possible.
        // This makes it easier to debug and is also required for function registration.
        // We can either give it a custom name or use the function's type name as
        // derived from `std::any::type_name_of_val`.
        SignatureInfo::named(std::any::type_name_of_val(&get_or_insert))
            // We can always change the name if needed.
            // It's a good idea to also ensure that the name is unique,
            // such as by using its type name or by prefixing it with your crate name.
            .with_name("my_crate::get_or_insert")
            // Since our function takes arguments, we should provide that argument information.
            // This is used to validate arguments when calling the function.
            // And it aids consumers of the function with their own validation and debugging.
            // Arguments should be provided in the order they are defined in the function.
            .with_arg::<i32>("value")
            .with_arg::<&mut Option<i32>>("container")
            // We can provide return information as well.
            .with_return::<&i32>(),
    ));

    let mut container: Option<i32> = None;

    let args = dbg!(ArgList::new().with_owned(5_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));

    let args = dbg!(ArgList::new().with_owned(500_i32).with_mut(&mut container));
    let value = dbg!(get_or_insert_function.call(args).unwrap()).unwrap_ref();
    assert_eq!(value.try_downcast_ref::<i32>(), Some(&5));
}

examples/reflection/dynamic_types.rs (line 73)

fn main() {
    #[derive(Reflect, Default, PartialEq, Debug)]
    #[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.
    // This trait object also gives us access to all the methods in the `PartialReflect` trait too.
    // 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());

    // We can attempt to clone our value using `PartialReflect::reflect_clone`.
    // This will recursively call `PartialReflect::reflect_clone` on all fields of the type.
    // Or, if we had registered `ReflectClone` using `#[reflect(Clone)]`, it would simply call `Clone::clone` directly.
    let cloned: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
    assert_eq!(cloned.downcast_ref::<Player>(), Some(&Player { id: 123 }));

    // Another way we can "clone" our data is by converting it to a dynamic type.
    // Notice here we bind it as a `dyn PartialReflect` instead of `dyn Reflect`.
    // This is because it returns a dynamic type that simply represents the original type.
    // In this case, because `Player` is a struct, it will return a `DynamicStruct`.
    let dynamic: Box<dyn PartialReflect> = reflected.to_dynamic();
    assert!(dynamic.is_dynamic());

    // And if we try to convert it back to a `dyn Reflect` trait object, we'll get `None`.
    // Dynamic types cannot be directly cast to `dyn Reflect` trait objects.
    assert!(dynamic.try_as_reflect().is_none());

    // Generally dynamic types are used to represent (or "proxy") the original type,
    // so that we can continue to access its fields and overall structure.
    let dynamic_ref = dynamic.reflect_ref().as_struct().unwrap();
    let id = dynamic_ref.field("id").unwrap().try_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.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");

    // Trying to access the registry with our `deserialized` will give a compile error
    // since it doesn't implement `Reflect`, only `PartialReflect`.
    // Similarly, trying to force the operation will fail.
    // This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
    assert!(deserialized
        .try_as_reflect()
        .and_then(|reflect_trait_obj| reflect_identifiable.get(reflect_trait_obj))
        .is_none());

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

    // 1. Using `PartialReflect::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_ref());
        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_ref());

        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_ref()).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_ref())
            .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
    // `PartialReflect::to_dynamic` or via the reflection deserializers,
    // you can also construct them manually.
    let mut my_dynamic_list = DynamicList::from_iter([1u32, 2u32, 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_partial_reflect()
        .represents::<Vec<u32>>());
    my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
    assert!(my_dynamic_list
        .as_partial_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_iter([1u32, 2u32, 3u32]);

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

    // 3. `DynamicList`
    {
        let dynamic_list = DynamicList::from_iter([1u32, 2u32, 3u32]);

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

    // 4. `DynamicSet`
    {
        let mut dynamic_set = DynamicSet::from_iter(["x", "y", "z"]);
        assert!(dynamic_set.contains(&"x"));

        dynamic_set.remove(&"y");

        let mut my_set: HashSet<&str> = HashSet::default();
        my_set.apply(&dynamic_set);
        assert_eq!(my_set, HashSet::from_iter(["x", "z"]));
    }

    // 5. `DynamicMap`
    {
        let dynamic_map = DynamicMap::from_iter([("x", 1u32), ("y", 2u32), ("z", 3u32)]);

        let mut my_map: HashMap<&str, u32> = HashMap::default();
        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));
    }

    // 6. `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 });
    }

    // 7. `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));
    }

    // 8. `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 try_downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Any,

Downcasts the value to type T by mutable reference.

If the underlying value does not implement Reflect or is not of type T, returns None.

For remote types, T should be the type itself rather than the wrapper type.

Trait Implementations

impl Debug for dyn PartialReflect

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

Formats the value using the given formatter.

impl FromIterator<Box<dyn PartialReflect>> for DynamicArray

fn from_iter<I>(values: I) -> DynamicArray

where I: IntoIterator<Item = Box<dyn PartialReflect>>,

Creates a value from an iterator.

impl FromIterator<Box<dyn PartialReflect>> for DynamicList

fn from_iter<I>(values: I) -> DynamicList

where I: IntoIterator<Item = Box<dyn PartialReflect>>,

Creates a value from an iterator.

impl FromIterator<Box<dyn PartialReflect>> for DynamicSet

fn from_iter<I>(values: I) -> DynamicSet

where I: IntoIterator<Item = Box<dyn PartialReflect>>,

Creates a value from an iterator.

impl FromIterator<Box<dyn PartialReflect>> for DynamicTuple

fn from_iter<I>(fields: I) -> DynamicTuple

where I: IntoIterator<Item = Box<dyn PartialReflect>>,

Creates a value from an iterator.

impl FromIterator<Box<dyn PartialReflect>> for DynamicTupleStruct

fn from_iter<I>(fields: I) -> DynamicTupleStruct

where I: IntoIterator<Item = Box<dyn PartialReflect>>,

Creates a value from an iterator.

impl TypePath for dyn PartialReflect

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

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

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

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

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

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

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

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

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl PartialReflect for &'static Location<'static>

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

fn into_partial_reflect( self: Box<&'static Location<'static>>, ) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<&'static Location<'static>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

impl PartialReflect for &'static Path

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

fn into_partial_reflect(self: Box<&'static Path>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<&'static Path>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

impl PartialReflect for &'static str

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

fn into_partial_reflect(self: Box<&'static str>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<&'static str>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

impl PartialReflect for ()

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

fn into_partial_reflect(self: Box<()>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<()>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for Atomic<bool>

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

fn into_partial_reflect(self: Box<Atomic<bool>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<bool>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<i8>

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

fn into_partial_reflect(self: Box<Atomic<i8>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<i8>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<i16>

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

fn into_partial_reflect(self: Box<Atomic<i16>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<i16>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<i32>

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

fn into_partial_reflect(self: Box<Atomic<i32>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<i32>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<i64>

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

fn into_partial_reflect(self: Box<Atomic<i64>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<i64>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<isize>

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

fn into_partial_reflect(self: Box<Atomic<isize>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<isize>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<u8>

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

fn into_partial_reflect(self: Box<Atomic<u8>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<u8>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<u16>

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

fn into_partial_reflect(self: Box<Atomic<u16>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<u16>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<u32>

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

fn into_partial_reflect(self: Box<Atomic<u32>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<u32>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<u64>

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

fn into_partial_reflect(self: Box<Atomic<u64>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<u64>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Atomic<usize>

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

fn into_partial_reflect(self: Box<Atomic<usize>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Atomic<usize>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

impl PartialReflect for Cow<'static, Path>

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

fn into_partial_reflect( self: Box<Cow<'static, Path>>, ) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

impl PartialReflect for Cow<'static, str>

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

fn into_partial_reflect(self: Box<Cow<'static, str>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

impl PartialReflect for Duration

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<Duration>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Duration>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NodeIndex

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<NodeIndex>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NodeIndex>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<i8>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<i8>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<i8>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<i16>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<i16>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<i16>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<i32>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<i32>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<i32>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<i64>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<i64>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<i64>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<i128>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<i128>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<i128>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<isize>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<isize>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<isize>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<u8>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<u8>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<u8>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<u16>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<u16>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<u16>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<u32>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<u32>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<u32>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<u64>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<u64>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<u64>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<u128>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<u128>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<u128>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for NonZero<usize>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

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 try_into_reflect( self: Box<NonZero<usize>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<NonZero<usize>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for OsString

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<OsString>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<OsString>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for PathBuf

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<PathBuf>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<PathBuf>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for RangeFull

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<RangeFull>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RangeFull>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for SmolStr

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<SmolStr>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<SmolStr>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for SocketAddr

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<SocketAddr>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<SocketAddr>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for TypeId

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<TypeId>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<TypeId>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for bool

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<bool>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<bool>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for char

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<char>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<char>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for f32

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<f32>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<f32>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for f64

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<f64>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<f64>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for i8

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<i8>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<i8>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for i16

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<i16>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<i16>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for i32

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<i32>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<i32>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for i64

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<i64>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<i64>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for i128

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<i128>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<i128>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for isize

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<isize>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<isize>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for u8

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<u8>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<u8>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for u16

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<u16>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<u16>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for u32

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<u32>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<u32>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for u64

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<u64>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<u64>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for u128

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<u128>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<u128>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl PartialReflect for usize

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<usize>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<usize>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration, K: Reflect + MaybeTyped + TypePath + GetTypeRegistration, L: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration, K: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration, J: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration, I: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration, H: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration, G: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration, F: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration, E: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration, D: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<(A, B, C, D)>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration, C: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<(A, B, C)>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<(A, B, C)>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration, B: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<(A, B)>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<(A, B)>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<A> PartialReflect for (A,)

where A: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<(A,)>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<(A,)>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration, S: TypePath + BuildHasher + Default + Send + Sync,

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

fn into_partial_reflect(self: Box<HashMap<K, V, S>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

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

impl<K, V, S> PartialReflect for IndexMap<K, V, S>

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration, S: TypePath + BuildHasher + Default + Send + Sync,

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

fn into_partial_reflect(self: Box<IndexMap<K, V, S>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<IndexMap<K, V, S>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Ord, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<BTreeMap<K, V>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<BTreeMap<K, V>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

impl<N, E, Ix> PartialReflect 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 to_dynamic(&self) -> Box<dyn PartialReflect>

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

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

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

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T, E> PartialReflect for Result<T, E>

where Result<T, E>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection, E: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

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

fn try_apply( &mut self, __value_param: &(dyn PartialReflect + '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 try_into_reflect( self: Box<Result<T, E>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Result<T, E>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T, S> PartialReflect for IndexSet<T, S>

where T: FromReflect + TypePath + GetTypeRegistration + Eq + Hash, S: TypePath + BuildHasher + Default + Send + Sync,

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

fn into_partial_reflect(self: Box<IndexSet<T, S>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<IndexSet<T, S>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<IndexSet<T, S>>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

impl<T, const N: usize> PartialReflect for [T; N]

where T: Reflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<[T; N]>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<[T; N]>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_hash(&self) -> Option<u64>

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

impl<T> PartialReflect 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 to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<BTreeSet<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<BTreeSet<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for BinaryHeap<T>

where T: Clone + TypePath, BinaryHeap<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<BinaryHeap<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<BinaryHeap<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for Bound<T>

where T: Clone + Send + Sync + TypePath, Bound<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<Bound<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Bound<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

where T: FromReflect + MaybeTyped + Clone + TypePath + GetTypeRegistration,

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Cow<'static, [T]>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

impl<T> PartialReflect for Option<T>

where Option<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

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

fn try_apply( &mut self, __value_param: &(dyn PartialReflect + '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 try_into_reflect( self: Box<Option<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Option<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for Range<T>

where T: Clone + Send + Sync + TypePath, Range<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<Range<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Range<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeFrom<T>

where T: Clone + Send + Sync + TypePath, RangeFrom<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<RangeFrom<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RangeFrom<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeInclusive<T>

where T: Clone + Send + Sync + TypePath, RangeInclusive<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<RangeInclusive<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RangeInclusive<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeTo<T>

where T: Clone + Send + Sync + TypePath, RangeTo<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<RangeTo<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RangeTo<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for RangeToInclusive<T>

where T: Clone + Send + Sync + TypePath, RangeToInclusive<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<RangeToInclusive<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect( self: Box<RangeToInclusive<T>>, ) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for Saturating<T>

where T: Clone + Send + Sync + TypePath, Saturating<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<Saturating<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Saturating<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<T> PartialReflect for SmallVec<T>

where T: Array + TypePath + Send + Sync, <T as Array>::Item: FromReflect + MaybeTyped + TypePath,

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

fn into_partial_reflect(self: Box<SmallVec<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<SmallVec<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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

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

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

impl<T> PartialReflect for VecDeque<T>

where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

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

fn into_partial_reflect(self: Box<VecDeque<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<VecDeque<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

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

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

impl<T> PartialReflect for Wrapping<T>

where T: Clone + Send + Sync + TypePath, Wrapping<T>: Any + Send + Sync,

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<Wrapping<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Wrapping<T>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

impl<V, S> PartialReflect for HashSet<V, S>

where V: FromReflect + TypePath + GetTypeRegistration + Eq + Hash, S: TypePath + BuildHasher + Default + Send + Sync,

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

fn into_partial_reflect(self: Box<HashSet<V, S>>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<HashSet<V, S>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

Implementors

impl PartialReflect for Aabb

impl PartialReflect for Aabb2d

impl PartialReflect for Aabb3d

impl PartialReflect for AabbCast2d

impl PartialReflect for AabbCast3d

impl PartialReflect for AabbGizmoConfigGroup

impl PartialReflect for AccessibilityRequested

impl PartialReflect for AccessibilitySystems

impl PartialReflect for AccessibleLabel

impl PartialReflect for AccumulatedMouseMotion

impl PartialReflect for AccumulatedMouseScroll

impl PartialReflect for AcquireFocus

impl PartialReflect for Activate

impl PartialReflect for ActivateOnPress

impl PartialReflect for ActiveAnimation

impl PartialReflect for ActiveDescendant

impl PartialReflect for Add

impl PartialReflect for Affine2

impl PartialReflect for Affine3

impl PartialReflect for Affine3A

impl PartialReflect for AlignContent

impl PartialReflect for AlignItems

impl PartialReflect for AlignSelf

impl PartialReflect for AlphaMode

impl PartialReflect for AlphaMode2d

impl PartialReflect for AmbientLight

impl PartialReflect for Anchor

impl PartialReflect for AngularColorStop

impl PartialReflect for AnimatedBy

impl PartialReflect for AnimationClip

impl PartialReflect for AnimationGraph

impl PartialReflect for AnimationGraphHandle

impl PartialReflect for AnimationGraphNode

impl PartialReflect for AnimationNodeType

impl PartialReflect for AnimationPlayer

impl PartialReflect for AnimationTargetId

impl PartialReflect for AnimationTransition

impl PartialReflect for AnimationTransitions

impl PartialReflect for Annulus

impl PartialReflect for AnnulusMeshBuilder

impl PartialReflect for AppExit

impl PartialReflect for AppLifecycle

impl PartialReflect for Arc2d

impl PartialReflect for AspectRatio

impl PartialReflect for AssetIndex

impl PartialReflect for AtmosphereMode

impl PartialReflect for AtmosphereSettings

impl PartialReflect for AutoDirectionalNavigation

impl PartialReflect for AutoExposure

impl PartialReflect for AutoExposureCompensationCurve

impl PartialReflect for AutoFocus

impl PartialReflect for AutoNavigationConfig

impl PartialReflect for AxisSettings

impl PartialReflect for BVec2

impl PartialReflect for BVec3

impl PartialReflect for BVec4

impl PartialReflect for BVec3A

impl PartialReflect for BVec4A

impl PartialReflect for Backfaces

impl PartialReflect for BackgroundColor

impl PartialReflect for BackgroundGradient

impl PartialReflect for BlendState

impl PartialReflect for Bloom

impl PartialReflect for BloomCompositeMode

impl PartialReflect for BloomPrefilter

impl PartialReflect for BorderColor

impl PartialReflect for BorderGradient

impl PartialReflect for BorderRadius

impl PartialReflect for BorderRect

impl PartialReflect for BoundingCircle

impl PartialReflect for BoundingCircleCast

impl PartialReflect for BoundingSphere

impl PartialReflect for BoundingSphereCast

impl PartialReflect for BoxShadow

impl PartialReflect for BoxShadowSamples

impl PartialReflect for BoxSizing

impl PartialReflect for bevy::prelude::Button

impl PartialReflect for bevy::ui_widgets::Button

impl PartialReflect for ButtonAxisSettings

impl PartialReflect for ButtonSettings

impl PartialReflect for ButtonState

impl PartialReflect for ButtonVariant

impl PartialReflect for CalculatedClip

impl PartialReflect for Camera

impl PartialReflect for Camera2d

impl PartialReflect for Camera3d

impl PartialReflect for Camera3dDepthLoadOp

impl PartialReflect for Camera3dDepthTextureUsage

impl PartialReflect for CameraMainTextureUsages

impl PartialReflect for CameraOutputMode

impl PartialReflect for CameraRenderGraph

impl PartialReflect for Cancel

impl PartialReflect for Capsule2d

impl PartialReflect for Capsule2dMeshBuilder

impl PartialReflect for Capsule3d

impl PartialReflect for Capsule3dMeshBuilder

impl PartialReflect for CapsuleUvProfile

impl PartialReflect for Cascade

impl PartialReflect for CascadeShadowConfig

impl PartialReflect for Cascades

impl PartialReflect for CascadesFrusta

impl PartialReflect for CascadesVisibleEntities

impl PartialReflect for Checkable

impl PartialReflect for Checkbox

impl PartialReflect for Checked

impl PartialReflect for ChildOf

impl PartialReflect for Children

impl PartialReflect for ChromaticAberration

impl PartialReflect for Circle

impl PartialReflect for CircleMeshBuilder

impl PartialReflect for CircularMeshUvMode

impl PartialReflect for CircularSector

impl PartialReflect for CircularSectorMeshBuilder

impl PartialReflect for CircularSegment

impl PartialReflect for CircularSegmentMeshBuilder

impl PartialReflect for ClearColor

impl PartialReflect for ClearColorConfig

impl PartialReflect for Click

impl PartialReflect for ClusterConfig

impl PartialReflect for ClusterFarZMode

impl PartialReflect for ClusterZConfig

impl PartialReflect for ClusteredDecal

impl PartialReflect for Color

impl PartialReflect for ColorChannel

impl PartialReflect for ColorGrading

impl PartialReflect for ColorGradingGlobal

impl PartialReflect for ColorGradingSection

impl PartialReflect for ColorMaterial

impl PartialReflect for ColorPlaneValue

impl PartialReflect for ColorSlider

impl PartialReflect for ColorStop

impl PartialReflect for ColorSwatchFg

impl PartialReflect for ColorSwatchValue

impl PartialReflect for CompassOctant

impl PartialReflect for CompassQuadrant

impl PartialReflect for ComponentId

impl PartialReflect for ComponentTicks

impl PartialReflect for CompositeAlphaMode

impl PartialReflect for CompositingSpace

impl PartialReflect for ComputedCameraValues

impl PartialReflect for ComputedNode

impl PartialReflect for ComputedStackIndex

impl PartialReflect for ComputedTextBlock

impl PartialReflect for ComputedUiRenderTargetInfo

impl PartialReflect for ComputedUiTargetCamera

impl PartialReflect for Cone

impl PartialReflect for ConeAnchor

impl PartialReflect for ConeMeshBuilder

impl PartialReflect for ConicGradient

impl PartialReflect for ConicalFrustum

impl PartialReflect for ConicalFrustumMeshBuilder

impl PartialReflect for ContactShadows

impl PartialReflect for ContentSize

impl PartialReflect for ContrastAdaptiveSharpening

impl PartialReflect for ControlOrientation

impl PartialReflect for ConvexPolygon

impl PartialReflect for ConvexPolygonMeshBuilder

impl PartialReflect for CubemapFrusta

impl PartialReflect for CubemapLayout

impl PartialReflect for CubemapVisibleEntities

impl PartialReflect for CubicRotationCurve

impl PartialReflect for Cuboid

impl PartialReflect for CuboidMeshBuilder

impl PartialReflect for CursorEntered

impl PartialReflect for CursorGrabMode

impl PartialReflect for CursorIcon

impl PartialReflect for CursorLeft

impl PartialReflect for CursorMoved

impl PartialReflect for CursorOptions

impl PartialReflect for CustomCursor

impl PartialReflect for CustomCursorImage

impl PartialReflect for CustomCursorUrl

impl PartialReflect for CustomProjection

impl PartialReflect for Cylinder

impl PartialReflect for CylinderAnchor

impl PartialReflect for CylinderMeshBuilder

impl PartialReflect for DAffine2

impl PartialReflect for DAffine3

impl PartialReflect for DMat2

impl PartialReflect for DMat3

impl PartialReflect for DMat4

impl PartialReflect for DQuat

impl PartialReflect for DVec2

impl PartialReflect for DVec3

impl PartialReflect for DVec4

impl PartialReflect for DebandDither

impl PartialReflect for DefaultCursor

impl PartialReflect for DefaultGizmoConfigGroup

impl PartialReflect for DefaultOpaqueRendererMethod

impl PartialReflect for DefaultQueryFilters

impl PartialReflect for DefaultSpatialScale

impl PartialReflect for DeferredPrepass

impl PartialReflect for DeferredPrepassDoubleBuffer

impl PartialReflect for DelayedCommandQueue

impl PartialReflect for DenoiseCas

impl PartialReflect for DepthOfField

impl PartialReflect for DepthOfFieldMode

impl PartialReflect for DepthPrepass

impl PartialReflect for DepthPrepassDoubleBuffer

impl PartialReflect for Despawn

impl PartialReflect for Dir2

impl PartialReflect for Dir3

impl PartialReflect for Dir4

impl PartialReflect for Dir3A

impl PartialReflect for DirectionalLight

impl PartialReflect for DirectionalLightShadowMap

impl PartialReflect for DirectionalLightTexture

impl PartialReflect for DirectionalNavigationMap

impl PartialReflect for DirectlyHovered

impl PartialReflect for Disabled

impl PartialReflect for Discard

impl PartialReflect for Display

impl PartialReflect for DistanceFog

impl PartialReflect for DoubleTapGesture

impl PartialReflect for Drag

impl PartialReflect for DragDrop

impl PartialReflect for DragEnd

impl PartialReflect for DragEnter

impl PartialReflect for DragEntry

impl PartialReflect for DragLeave

impl PartialReflect for DragOver

impl PartialReflect for DragStart

impl PartialReflect for DynamicArray

impl PartialReflect for DynamicEnum

impl PartialReflect for DynamicFunction<'static>

impl PartialReflect for DynamicList

impl PartialReflect for DynamicMap

impl PartialReflect for DynamicSet

impl PartialReflect for DynamicSkinnedMeshBounds

impl PartialReflect for DynamicStruct

impl PartialReflect for DynamicTuple

impl PartialReflect for DynamicTupleStruct

impl PartialReflect for DynamicWorldRoot

impl PartialReflect for EaseFunction

impl PartialReflect for Ellipse

impl PartialReflect for EllipseMeshBuilder

impl PartialReflect for EnabledButtons

impl PartialReflect for Enter

impl PartialReflect for Entity

impl PartialReflect for EntityCursor

impl PartialReflect for EntityGeneration

impl PartialReflect for EntityHash

impl PartialReflect for EntityHashSet

impl PartialReflect for EntityIndex

impl PartialReflect for EntityIndexSet

impl PartialReflect for EnvironmentMapLight

impl PartialReflect for ErasedGizmoConfigGroup

impl PartialReflect for EulerRot

impl PartialReflect for Exposure

impl PartialReflect for FeathersButton

impl PartialReflect for FeathersCheckbox

impl PartialReflect for FeathersColorPlane

impl PartialReflect for FeathersColorSlider

impl PartialReflect for FeathersColorSwatch

impl PartialReflect for FeathersDisclosureToggle

impl PartialReflect for FeathersListRow

impl PartialReflect for FeathersListView

impl PartialReflect for FeathersMenu

impl PartialReflect for FeathersMenuButton

impl PartialReflect for FeathersMenuDivider

impl PartialReflect for FeathersMenuItem

impl PartialReflect for FeathersMenuPopup

impl PartialReflect for FeathersNumberInput

impl PartialReflect for FeathersRadio

impl PartialReflect for FeathersScrollbar

impl PartialReflect for FeathersSlider

impl PartialReflect for FeathersTextInput

impl PartialReflect for FeathersTextInputContainer

impl PartialReflect for FeathersToggleSwitch

impl PartialReflect for FeathersToolButton

impl PartialReflect for FileDragAndDrop

impl PartialReflect for Fixed

impl PartialReflect for FlexDirection

impl PartialReflect for FlexWrap

impl PartialReflect for FloatOrd

impl PartialReflect for FocusCause

impl PartialReflect for FocusGained

impl PartialReflect for FocusIndicator

impl PartialReflect for FocusLost

impl PartialReflect for FocusPolicy

impl PartialReflect for FocusWithinIndicator

impl PartialReflect for FocusableArea

impl PartialReflect for FogFalloff

impl PartialReflect for FogVolume

impl PartialReflect for FontFeatureTag

impl PartialReflect for FontFeatures

impl PartialReflect for FontHinting

impl PartialReflect for FontSize

impl PartialReflect for FontSmoothing

impl PartialReflect for FontSource

impl PartialReflect for FontStyle

impl PartialReflect for FontVariationTag

impl PartialReflect for FontVariations

impl PartialReflect for FontWeight

impl PartialReflect for FontWidth

impl PartialReflect for ForceTouch

impl PartialReflect for ForwardDecal

impl PartialReflect for FpsOverlayConfig

impl PartialReflect for FrameTimeGraphConfig

impl PartialReflect for Frustum

impl PartialReflect for FrustumGizmoConfigGroup

impl PartialReflect for Fxaa

impl PartialReflect for Gamepad

impl PartialReflect for GamepadAxis

impl PartialReflect for GamepadAxisChangedEvent

impl PartialReflect for GamepadButton

impl PartialReflect for GamepadButtonChangedEvent

impl PartialReflect for GamepadButtonStateChangedEvent

impl PartialReflect for GamepadConnection

impl PartialReflect for GamepadConnectionEvent

impl PartialReflect for GamepadEvent

impl PartialReflect for GamepadInput

impl PartialReflect for GamepadRumbleIntensity

impl PartialReflect for GamepadRumbleRequest

impl PartialReflect for GamepadSettings

impl PartialReflect for GeneratedEnvironmentMapLight

impl PartialReflect for GhostNode

impl PartialReflect for Gizmo

impl PartialReflect for GizmoConfig

impl PartialReflect for GizmoConfigStore

impl PartialReflect for GizmoLineConfig

impl PartialReflect for GizmoLineJoint

impl PartialReflect for GizmoLineStyle

impl PartialReflect for GlobalAmbientLight

impl PartialReflect for GlobalRenderDebugOverlay

impl PartialReflect for GlobalTransform

impl PartialReflect for GlobalUiDebugOptions

impl PartialReflect for GlobalVolume

impl PartialReflect for GlobalZIndex

impl PartialReflect for GlobalsUniform

impl PartialReflect for GltfExtras

impl PartialReflect for GltfMaterialExtras

impl PartialReflect for GltfMaterialName

impl PartialReflect for GltfMeshExtras

impl PartialReflect for GltfMeshName

impl PartialReflect for GltfSceneExtras

impl PartialReflect for GltfSceneName

impl PartialReflect for GlyphAtlasInfo

impl PartialReflect for GlyphAtlasLocation

impl PartialReflect for GpuAtmosphereSettings

impl PartialReflect for Gradient

impl PartialReflect for GridAutoFlow

impl PartialReflect for GridPlacement

impl PartialReflect for GridTrack

impl PartialReflect for GridTrackRepetition

impl PartialReflect for HalfSpace

impl PartialReflect for HashedStr

impl PartialReflect for Hdr

impl PartialReflect for HitData

impl PartialReflect for Hovered

impl PartialReflect for Hsla

impl PartialReflect for Hsva

impl PartialReflect for Hwba

impl PartialReflect for I8Vec2

impl PartialReflect for I8Vec3

impl PartialReflect for I8Vec4

impl PartialReflect for I16Vec2

impl PartialReflect for I16Vec3

impl PartialReflect for I16Vec4

impl PartialReflect for I64Vec2

impl PartialReflect for I64Vec3

impl PartialReflect for I64Vec4

impl PartialReflect for IRect

impl PartialReflect for IVec2

impl PartialReflect for IVec3

impl PartialReflect for IVec4

impl PartialReflect for IgnoreScroll

impl PartialReflect for Image

impl PartialReflect for ImageAddressMode

impl PartialReflect for ImageCompareFunction

impl PartialReflect for ImageFilterMode

impl PartialReflect for ImageNode

impl PartialReflect for ImageNodeSize

impl PartialReflect for ImageRenderTarget

impl PartialReflect for ImageSampler

impl PartialReflect for ImageSamplerBorderColor

impl PartialReflect for ImageSamplerDescriptor

impl PartialReflect for Ime

impl PartialReflect for Indices

impl PartialReflect for InfiniteGrid

impl PartialReflect for InfiniteGridSettings

impl PartialReflect for InfinitePlane3d

impl PartialReflect for InheritableFont

impl PartialReflect for InheritableThemeTextColor

impl PartialReflect for InheritedVisibility

impl PartialReflect for InlineDirection

impl PartialReflect for InputFocus

impl PartialReflect for InputFocusVisible

impl PartialReflect for Insert

impl PartialReflect for InstanceId

impl PartialReflect for Instant

impl PartialReflect for Interaction

impl PartialReflect for InteractionDisabled

impl PartialReflect for InternalWindowState

impl PartialReflect for InterpolationColorSpace

impl PartialReflect for Interval

impl PartialReflect for IrradianceVolume

impl PartialReflect for IsDefaultUiCamera

impl PartialReflect for IsResource

impl PartialReflect for Isometry2d

impl PartialReflect for Isometry3d

impl PartialReflect for JointAabb

impl PartialReflect for JointIndex

impl PartialReflect for JumpAt

impl PartialReflect for Justify

impl PartialReflect for JustifyContent

impl PartialReflect for JustifyItems

impl PartialReflect for JustifySelf

impl PartialReflect for Key

impl PartialReflect for KeyCode

impl PartialReflect for KeyboardFocusLost

impl PartialReflect for KeyboardInput

impl PartialReflect for Laba

impl PartialReflect for Label

impl PartialReflect for LayoutConfig

impl PartialReflect for Lcha

impl PartialReflect for Leave

impl PartialReflect for LensDistortion

impl PartialReflect for LetterSpacing

impl PartialReflect for LightGizmoColor

impl PartialReflect for LightGizmoConfigGroup

impl PartialReflect for LightProbe

impl PartialReflect for Lightmap

impl PartialReflect for Line2d

impl PartialReflect for Line3d

impl PartialReflect for LineBreak

impl PartialReflect for LineGizmoEntities

impl PartialReflect for LineHeight

impl PartialReflect for LinearGradient

impl PartialReflect for LinearRgba

impl PartialReflect for ListItem

impl PartialReflect for bevy::picking::pointer::Location

impl PartialReflect for MainEntity

impl PartialReflect for MainPassResolutionOverride

impl PartialReflect for ManageAccessibilityUpdates

impl PartialReflect for ManualTextureViewHandle

impl PartialReflect for Mat2

impl PartialReflect for Mat3

impl PartialReflect for Mat4

impl PartialReflect for Mat3A

impl PartialReflect for MaterialBindGroupIndex

impl PartialReflect for MaterialBindGroupSlot

impl PartialReflect for MaterialBindingId

impl PartialReflect for MaxTrackSizingFunction

impl PartialReflect for MenuAction

impl PartialReflect for MenuButton

impl PartialReflect for MenuEvent

impl PartialReflect for MenuFocusState

impl PartialReflect for MenuItem

impl PartialReflect for MenuLayout

impl PartialReflect for MenuPopup

impl PartialReflect for Mesh

impl PartialReflect for Mesh2d

impl PartialReflect for Mesh2dWireframe

impl PartialReflect for Mesh3d

impl PartialReflect for Mesh3dWireframe

impl PartialReflect for MeshMorphWeights

impl PartialReflect for MeshPickingCamera

impl PartialReflect for MeshPickingSettings

impl PartialReflect for MeshTag

impl PartialReflect for MeshletMesh3d

impl PartialReflect for MinTrackSizingFunction

impl PartialReflect for MipBias

impl PartialReflect for Monitor

impl PartialReflect for MonitorSelection

impl PartialReflect for MorphAttributes

impl PartialReflect for MorphWeights

impl PartialReflect for MotionBlur

impl PartialReflect for MotionVectorPrepass

impl PartialReflect for MouseButton

impl PartialReflect for MouseButtonInput

impl PartialReflect for MouseMotion

impl PartialReflect for MouseScrollUnit

impl PartialReflect for MouseWheel

impl PartialReflect for Move

impl PartialReflect for Msaa

impl PartialReflect for MsaaWriteback

impl PartialReflect for Name

impl PartialReflect for NativeKey

impl PartialReflect for NativeKeyCode

impl PartialReflect for NavAction

impl PartialReflect for NavNeighbor

impl PartialReflect for NavNeighbors

impl PartialReflect for NoAutoAabb

impl PartialReflect for NoBackgroundMotionVectors

impl PartialReflect for NoFrustumCulling

impl PartialReflect for NoWireframe

impl PartialReflect for NoWireframe2d

impl PartialReflect for Node

impl PartialReflect for NodeImageMode

impl PartialReflect for NonNilUuid

impl PartialReflect for NormalPrepass

impl PartialReflect for NormalizedRenderTarget

impl PartialReflect for NormalizedWindowRef

impl PartialReflect for NotShadowCaster

impl PartialReflect for NotShadowReceiver

impl PartialReflect for NumberFormat

impl PartialReflect for NumberInputValue

impl PartialReflect for ObservedBy

impl PartialReflect for OcclusionCulling

impl PartialReflect for OffsetAccess

impl PartialReflect for Oklaba

impl PartialReflect for Oklcha

impl PartialReflect for OpaqueRendererMethod

impl PartialReflect for OrderIndependentTransparencySettings

impl PartialReflect for OrthographicProjection

impl PartialReflect for Out

impl PartialReflect for OuterColor

impl PartialReflect for Outline

impl PartialReflect for Over

impl PartialReflect for Overflow

impl PartialReflect for OverflowAxis

impl PartialReflect for OverflowClipMargin

impl PartialReflect for OverrideClip

impl PartialReflect for OverrideCursor

impl PartialReflect for PanGesture

impl PartialReflect for ParallaxCorrection

impl PartialReflect for ParallaxMappingMethod

impl PartialReflect for ParsedPath

impl PartialReflect for Pathtracer

impl PartialReflect for PerspectiveProjection

impl PartialReflect for Pickable

impl PartialReflect for PickingInteraction

impl PartialReflect for PickingSettings

impl PartialReflect for PinchGesture

impl PartialReflect for Plane2d

impl PartialReflect for Plane3d

impl PartialReflect for PlaneMeshBuilder

impl PartialReflect for PlaybackMode

impl PartialReflect for PlaybackSettings

impl PartialReflect for PointLight

impl PartialReflect for PointLightShadowMap

impl PartialReflect for PointLightTexture

impl PartialReflect for PointerAction

impl PartialReflect for PointerButton

impl PartialReflect for PointerHits

impl PartialReflect for PointerId

impl PartialReflect for PointerInput

impl PartialReflect for PointerInputSettings

impl PartialReflect for PointerInteraction

impl PartialReflect for PointerLocation

impl PartialReflect for PointerPress

impl PartialReflect for Polygon

impl PartialReflect for Polyline2d

impl PartialReflect for Polyline2dMeshBuilder

impl PartialReflect for Polyline3d

impl PartialReflect for Popover

impl PartialReflect for PopoverAlign

impl PartialReflect for PopoverPlacement

impl PartialReflect for PopoverSide

impl PartialReflect for PositionType

impl PartialReflect for PositionedGlyph

impl PartialReflect for PreeditCursor

impl PartialReflect for PresentMode

impl PartialReflect for Press

impl PartialReflect for PressDirection

impl PartialReflect for Pressed

impl PartialReflect for PrimaryMonitor

impl PartialReflect for PrimaryWindow

impl PartialReflect for Projection

impl PartialReflect for Quat

impl PartialReflect for RadialGradient

impl PartialReflect for RadialGradientShape

impl PartialReflect for RadioButton

impl PartialReflect for RadioGroup

impl PartialReflect for RawGamepadAxisChangedEvent

impl PartialReflect for RawGamepadButtonChangedEvent

impl PartialReflect for RawGamepadEvent

impl PartialReflect for Ray2d

impl PartialReflect for Ray3d

impl PartialReflect for RayCast2d

impl PartialReflect for RayCast3d

impl PartialReflect for RayCastBackfaces

impl PartialReflect for RayCastVisibility

impl PartialReflect for RayId

impl PartialReflect for RayMeshHit

impl PartialReflect for RaytracingMesh3d

impl PartialReflect for ReadbackComplete

impl PartialReflect for Real

impl PartialReflect for Rect

impl PartialReflect for RectLight

impl PartialReflect for Rectangle

impl PartialReflect for RectangleMeshBuilder

impl PartialReflect for RegularPolygon

impl PartialReflect for RegularPolygonMeshBuilder

impl PartialReflect for RelativeCursorPosition

impl PartialReflect for Release

impl PartialReflect for Remove

impl PartialReflect for RemovedComponentEntity

impl PartialReflect for RenderAssetUsages

impl PartialReflect for RenderDebugMode

impl PartialReflect for RenderDebugOverlay

impl PartialReflect for RenderDebugOverlayEvent

impl PartialReflect for RenderEntity

impl PartialReflect for RenderLayers

impl PartialReflect for RenderShadowMapVisibleEntities

impl PartialReflect for RenderTarget

impl PartialReflect for RenderTargetInfo

impl PartialReflect for RenderVisibleEntitiesClass

impl PartialReflect for RepeatAnimation

impl PartialReflect for RepeatedGridTrack

impl PartialReflect for RequestRedraw

impl PartialReflect for ResolvedBorderRadius

impl PartialReflect for Rhombus

impl PartialReflect for RhombusMeshBuilder

impl PartialReflect for RootNonCameraView

impl PartialReflect for Rot2

impl PartialReflect for RotationGesture

impl PartialReflect for RunGeometry

impl PartialReflect for ScalingMode

impl PartialReflect for SceneComponentInfo

impl PartialReflect for SchemaTypesMetadata

impl PartialReflect for ScreenEdge

impl PartialReflect for ScreenSpaceAmbientOcclusion

impl PartialReflect for ScreenSpaceAmbientOcclusionQualityLevel

impl PartialReflect for ScreenSpaceReflections

impl PartialReflect for ScreenSpaceTransmission

impl PartialReflect for ScreenSpaceTransmissionQuality

impl PartialReflect for Screenshot

impl PartialReflect for ScreenshotCaptured

impl PartialReflect for Scroll

impl PartialReflect for ScrollArea

impl PartialReflect for ScrollPosition

impl PartialReflect for Scrollbar

impl PartialReflect for ScrollbarDragState

impl PartialReflect for ScrollbarThumb

impl PartialReflect for Segment2d

impl PartialReflect for Segment3d

impl PartialReflect for SelectAllOnFocus

impl PartialReflect for Sensitivity

impl PartialReflect for SetChecked

impl PartialReflect for SetSliderValue

impl PartialReflect for ShaderBuffer

impl PartialReflect for ShadowFilteringMethod

impl PartialReflect for ShadowLodOrigin

impl PartialReflect for ShadowStyle

impl PartialReflect for ShowAabbGizmo

impl PartialReflect for ShowFrustumGizmo

impl PartialReflect for ShowLightGizmo

impl PartialReflect for ShowSkinnedMeshBoundsGizmo

impl PartialReflect for SimplifiedMesh

impl PartialReflect for SkinnedMesh

impl PartialReflect for SkinnedMeshBounds

impl PartialReflect for SkinnedMeshBoundsGizmoConfigGroup

impl PartialReflect for Skybox

impl PartialReflect for SliceScaleMode

impl PartialReflect for Slider

impl PartialReflect for SliderBaseColor

impl PartialReflect for SliderDragState

impl PartialReflect for SliderOrientation

impl PartialReflect for SliderPrecision

impl PartialReflect for SliderRange

impl PartialReflect for SliderStep

impl PartialReflect for SliderThumb

impl PartialReflect for SliderValue

impl PartialReflect for SliderValueChange

impl PartialReflect for Smaa

impl PartialReflect for SmaaPreset

impl PartialReflect for SolariLighting

impl PartialReflect for SpatialListener

impl PartialReflect for SpatialScale

impl PartialReflect for bevy::prelude::Sphere

impl PartialReflect for bevy::camera::primitives::Sphere

impl PartialReflect for SphereKind

impl PartialReflect for SphereMeshBuilder

impl PartialReflect for SpotLight

impl PartialReflect for SpotLightTexture

impl PartialReflect for Sprite

impl PartialReflect for SpriteAlphaMode

impl PartialReflect for SpriteImageMode

impl PartialReflect for SpriteMaterial

impl PartialReflect for SpriteMesh

impl PartialReflect for SpritePickingCamera

impl PartialReflect for SpritePickingMode

impl PartialReflect for SpritePickingSettings

impl PartialReflect for SpriteScalingMode

impl PartialReflect for Srgba

impl PartialReflect for StandardMaterial

impl PartialReflect for StaticTransformOptimizations

impl PartialReflect for Stopwatch

impl PartialReflect for Strikethrough

impl PartialReflect for StrikethroughColor

impl PartialReflect for String

impl PartialReflect for SubCameraView

impl PartialReflect for SyncToRenderWorld

impl PartialReflect for SystemCursorIcon

impl PartialReflect for TabGroup

impl PartialReflect for TabIndex

impl PartialReflect for TemporalAntiAliasing

impl PartialReflect for TemporalJitter

impl PartialReflect for TemporaryRenderEntity

impl PartialReflect for Tetrahedron

impl PartialReflect for TetrahedronMeshBuilder

impl PartialReflect for Text

impl PartialReflect for Text2d

impl PartialReflect for Text2dShadow

impl PartialReflect for TextBackgroundColor

impl PartialReflect for TextBounds

impl PartialReflect for TextColor

impl PartialReflect for TextEdit

impl PartialReflect for TextEntity

impl PartialReflect for TextFont

impl PartialReflect for TextLayout

impl PartialReflect for TextLayoutInfo

impl PartialReflect for TextNodeFlags

impl PartialReflect for TextScroll

impl PartialReflect for TextShadow

impl PartialReflect for TextSpan

impl PartialReflect for TextureAtlas

impl PartialReflect for TextureAtlasLayout

impl PartialReflect for TextureFormat

impl PartialReflect for TextureSlicer

impl PartialReflect for ThemeBackgroundColor

impl PartialReflect for ThemeBorderColor

impl PartialReflect for ThemeProps

impl PartialReflect for ThemeTextColor

impl PartialReflect for ThemeToken

impl PartialReflect for ThemedText

impl PartialReflect for ThreadedAnimationGraph

impl PartialReflect for ThreadedAnimationGraphs

impl PartialReflect for Tick

impl PartialReflect for TileData

impl PartialReflect for TileOrientation

impl PartialReflect for TilemapChunk

impl PartialReflect for TilemapChunkMeshCache

impl PartialReflect for TilemapChunkTileData

impl PartialReflect for Timer

impl PartialReflect for TimerMode

impl PartialReflect for ToggleChecked

impl PartialReflect for Tonemapping

impl PartialReflect for Torus

impl PartialReflect for TorusMeshBuilder

impl PartialReflect for TouchInput

impl PartialReflect for TouchPhase

impl PartialReflect for TrackClick

impl PartialReflect for Transform

impl PartialReflect for TransformGizmoAxis

impl PartialReflect for TransformGizmoCamera

impl PartialReflect for TransformGizmoFocus

impl PartialReflect for TransformGizmoMode

impl PartialReflect for TransformGizmoSettings

impl PartialReflect for TransformGizmoSpace

impl PartialReflect for TransformGizmoState

impl PartialReflect for TransformTreeChanged

impl PartialReflect for TransmittedShadowReceiver

impl PartialReflect for Triangle2d

impl PartialReflect for Triangle2dMeshBuilder

impl PartialReflect for Triangle3d

impl PartialReflect for Triangle3dMeshBuilder

impl PartialReflect for U8Vec2

impl PartialReflect for U8Vec3

impl PartialReflect for U8Vec4

impl PartialReflect for U16Vec2

impl PartialReflect for U16Vec3

impl PartialReflect for U16Vec4

impl PartialReflect for U64Vec2

impl PartialReflect for U64Vec3

impl PartialReflect for U64Vec4

impl PartialReflect for URect

impl PartialReflect for UVec2

impl PartialReflect for UVec3

impl PartialReflect for UVec4

impl PartialReflect for UiAntiAlias

impl PartialReflect for UiDebugOptions

impl PartialReflect for UiGlobalTransform

impl PartialReflect for UiPickingCamera

impl PartialReflect for UiPickingSettings

impl PartialReflect for UiPosition

impl PartialReflect for UiRect

impl PartialReflect for UiScale

impl PartialReflect for UiStack

impl PartialReflect for UiTargetCamera

impl PartialReflect for UiTheme

impl PartialReflect for UiTransform

impl PartialReflect for Underline

impl PartialReflect for UnderlineColor

impl PartialReflect for UntypedAssetId

impl PartialReflect for UntypedHandle

impl PartialReflect for UpdateNumberInput

impl PartialReflect for Uuid

impl PartialReflect for UvChannel

impl PartialReflect for Val

impl PartialReflect for Val2

impl PartialReflect for Vec2

impl PartialReflect for Vec3

impl PartialReflect for Vec4

impl PartialReflect for Vec3A

impl PartialReflect for VideoMode

impl PartialReflect for VideoModeSelection

impl PartialReflect for ViewFrustum

impl PartialReflect for ViewVisibility

impl PartialReflect for Viewport

impl PartialReflect for ViewportNode

impl PartialReflect for Vignette

impl PartialReflect for Virtual

impl PartialReflect for Visibility

impl PartialReflect for VisibilityClass

impl PartialReflect for VisibilityRange

impl PartialReflect for VisibleEntities

impl PartialReflect for VisibleMeshEntities

impl PartialReflect for VisualBox

impl PartialReflect for Volume

impl PartialReflect for VolumetricFog

impl PartialReflect for VolumetricLight

impl PartialReflect for WeightsCurveSample

impl PartialReflect for Window

impl PartialReflect for WindowBackendScaleFactorChanged

impl PartialReflect for WindowCloseRequested

impl PartialReflect for WindowClosed

impl PartialReflect for WindowClosing

impl PartialReflect for WindowCreated

impl PartialReflect for WindowDestroyed

impl PartialReflect for WindowEvent

impl PartialReflect for WindowFocused

impl PartialReflect for WindowLevel

impl PartialReflect for WindowMode

impl PartialReflect for WindowMoved

impl PartialReflect for WindowOccluded

impl PartialReflect for WindowPosition

impl PartialReflect for WindowRef

impl PartialReflect for WindowResizeConstraints

impl PartialReflect for WindowResized

impl PartialReflect for WindowResolution

impl PartialReflect for WindowScaleFactorChanged

impl PartialReflect for WindowTheme

impl PartialReflect for WindowThemeChanged

impl PartialReflect for WinitUserEvent

impl PartialReflect for Wireframe

impl PartialReflect for Wireframe2d

impl PartialReflect for Wireframe2dColor

impl PartialReflect for Wireframe2dConfig

impl PartialReflect for Wireframe2dMaterial

impl PartialReflect for WireframeColor

impl PartialReflect for WireframeConfig

impl PartialReflect for WireframeLineWidth

impl PartialReflect for WireframeMaterial

impl PartialReflect for WireframeTopology

impl PartialReflect for WorldAssetRoot

impl PartialReflect for WorldInstanceReady

impl PartialReflect for Xyza

impl PartialReflect for ZIndex

impl<'a> PartialReflect for Access<'a>

where Access<'a>: 'static,

impl<'a> PartialReflect for AssetPath<'a>

where AssetPath<'a>: 'static,

impl<A> PartialReflect for AnimatableCurveEvaluator<A>

where A: Animatable + TypePath, AnimatableCurveEvaluator<A>: Any + Send + Sync, BasicAnimationCurveEvaluator<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Box<dyn AnimatableProperty<Property = A>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> PartialReflect for AssetEvent<A>

where A: Asset + TypePath, AssetEvent<A>: Any + Send + Sync, AssetId<A>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<A> PartialReflect for AssetId<A>

where A: Asset + TypePath, AssetId<A>: Any + Send + Sync,

impl<A> PartialReflect for Handle<A>

where A: Asset + TypePath, Handle<A>: Any + Send + Sync,

impl<B, E> PartialReflect for ExtendedMaterial<B, E>

where B: Material + FromReflect + TypePath + MaybeTyped + RegisterForReflection, E: MaterialExtension + FromReflect + TypePath + MaybeTyped + RegisterForReflection, ExtendedMaterial<B, E>: Any + Send + Sync,

impl<C> PartialReflect for Inherited<C>

where C: Component + Clone + PartialEq + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Inherited<C>: Any + Send + Sync,

impl<C> PartialReflect for Propagate<C>

where C: Component + Clone + PartialEq + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Propagate<C>: Any + Send + Sync,

impl<C> PartialReflect for PropagateOver<C>

where PropagateOver<C>: Any + Send + Sync, C: TypePath, PhantomData<fn() -> C>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<C> PartialReflect for PropagateStop<C>

where PropagateStop<C>: Any + Send + Sync, C: TypePath, PhantomData<fn() -> C>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<C> PartialReflect for SampleDerivativeWrapper<C>

where SampleDerivativeWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<C> PartialReflect for SampleTwoDerivativesWrapper<C>

where SampleTwoDerivativesWrapper<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<C> PartialReflect for WeightsCurve<C>

where WeightsCurve<C>: Any + Send + Sync, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<Config, Clear> PartialReflect for GizmoBuffer<Config, Clear>

where GizmoBuffer<Config, Clear>: Any + Send + Sync, Config: GizmoConfigGroup + TypePath, Clear: 'static + Send + Sync + TypePath,

impl<E> PartialReflect for Pointer<E>

where E: Debug + Clone + Reflect + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Pointer<E>: Any + Send + Sync,

impl<K, V, S> PartialReflect for bevy::platform::collections::HashMap<K, V, S>

where K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash, V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration, S: TypePath + BuildHasher + Default + Send + Sync,

impl<M> PartialReflect for FocusedInput<M>

where M: Message + Clone + TypePath + FromReflect + MaybeTyped + RegisterForReflection, FocusedInput<M>: Any + Send + Sync,

impl<M> PartialReflect for MaterialNode<M>

where M: UiMaterial + TypePath, MaterialNode<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<M> PartialReflect for MeshMaterial2d<M>

where M: Material2d + TypePath, MeshMaterial2d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<M> PartialReflect for MeshMaterial3d<M>

where M: Material + TypePath, MeshMaterial3d<M>: Any + Send + Sync, Handle<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<M> PartialReflect for MessageId<M>

where M: Message + TypePath, MessageId<M>: Any + Send + Sync,

impl<M> PartialReflect for Messages<M>

where M: Message + TypePath, Messages<M>: Any + Send + Sync, MessageSequence<M>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P, C> PartialReflect for AnimatableCurve<P, C>

where AnimatableCurve<P, C>: Any + Send + Sync, P: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicBSpline<P>

where P: VectorSpace + TypePath, CubicBSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicBezier<P>

where P: VectorSpace + TypePath, CubicBezier<P>: Any + Send + Sync, Vec<[P; 4]>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicCardinalSpline<P>

where P: VectorSpace + TypePath, CubicCardinalSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicCurve<P>

where P: VectorSpace + TypePath, CubicCurve<P>: Any + Send + Sync, Vec<CubicSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicHermite<P>

where P: VectorSpace + TypePath, CubicHermite<P>: Any + Send + Sync, Vec<(P, P)>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicNurbs<P>

where P: VectorSpace + TypePath, CubicNurbs<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for LinearSpline<P>

where P: VectorSpace + TypePath, LinearSpline<P>: Any + Send + Sync, Vec<P>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for RationalCurve<P>

where P: VectorSpace + TypePath, RationalCurve<P>: Any + Send + Sync, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<P> PartialReflect for RationalSegment<P>

where P: VectorSpace + TypePath, RationalSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<S, T, C, D> PartialReflect for ZipCurve<S, T, C, D>

where ZipCurve<S, T, C, D>: Any + Send + Sync, S: TypePath, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<S, T, C, F> PartialReflect for MapCurve<S, T, C, F>

where MapCurve<S, T, C, F>: Any + Send + Sync, C: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, S: TypePath, T: TypePath,

impl<S> PartialReflect for DespawnOnEnter<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, DespawnOnEnter<S>: Any + Send + Sync,

impl<S> PartialReflect for DespawnOnExit<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, DespawnOnExit<S>: Any + Send + Sync,

impl<S> PartialReflect for DespawnWhen<S>

where S: States + TypePath, DespawnWhen<S>: Any + Send + Sync, Box<dyn Fn(&StateTransitionEvent<S>) -> bool + Sync + Send>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<S> PartialReflect for DisableOnEnter<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, DisableOnEnter<S>: Any + Send + Sync,

impl<S> PartialReflect for DisableOnExit<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, DisableOnExit<S>: Any + Send + Sync,

impl<S> PartialReflect for DisableWhen<S>

where S: States + TypePath, DisableWhen<S>: Any + Send + Sync, Box<dyn Fn(&StateTransitionEvent<S>) -> bool + Sync + Send>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<S> PartialReflect for EnableOnEnter<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, EnableOnEnter<S>: Any + Send + Sync,

impl<S> PartialReflect for EnableOnExit<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, EnableOnExit<S>: Any + Send + Sync,

impl<S> PartialReflect for EnableWhen<S>

where S: States + TypePath, EnableWhen<S>: Any + Send + Sync, Box<dyn Fn(&StateTransitionEvent<S>) -> bool + Sync + Send>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<S> PartialReflect for NextState<S>

where S: FreelyMutableState + TypePath + FromReflect + MaybeTyped + RegisterForReflection, NextState<S>: Any + Send + Sync,

impl<S> PartialReflect for PreviousState<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, PreviousState<S>: Any + Send + Sync,

impl<S> PartialReflect for State<S>

where S: States + TypePath + FromReflect + MaybeTyped + RegisterForReflection, State<S>: Any + Send + Sync,

impl<Source> PartialReflect for AudioPlayer<Source>

where AudioPlayer<Source>: Any + Send + Sync, Source: Asset + Decodable + TypePath, Handle<Source>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T, C, D> PartialReflect for ChainCurve<T, C, D>

where ChainCurve<T, C, D>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, D> PartialReflect for ContinuationCurve<T, C, D>

where ContinuationCurve<T, C, D>: Any + Send + Sync, T: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, D> PartialReflect for CurveReparamCurve<T, C, D>

where CurveReparamCurve<T, C, D>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection, D: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C, F> PartialReflect for ReparamCurve<T, C, F>

where ReparamCurve<T, C, F>: Any + Send + Sync, C: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T, C> PartialReflect for ForeverCurve<T, C>

where ForeverCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for GraphCurve<T, C>

where GraphCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for LinearReparamCurve<T, C>

where LinearReparamCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for PingPongCurve<T, C>

where PingPongCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for RepeatCurve<T, C>

where RepeatCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, C> PartialReflect for ReverseCurve<T, C>

where ReverseCurve<T, C>: Any + Send + Sync, T: TypePath, C: TypePath + PartialReflect + MaybeTyped + RegisterForReflection,

impl<T, F> PartialReflect for FunctionCurve<T, F>

where FunctionCurve<T, F>: Any + Send + Sync, T: TypePath,

impl<T, H> PartialReflect for Hashed<T, H>

where T: Clone + Send + Sync + TypePath, H: Send + Sync + TypePath, Hashed<T, H>: Any + Send + Sync,

impl<T, I> PartialReflect for SampleCurve<T, I>

where SampleCurve<T, I>: Any + Send + Sync, EvenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T, I> PartialReflect for UnevenSampleCurve<T, I>

where UnevenSampleCurve<T, I>: Any + Send + Sync, UnevenCore<T>: PartialReflect + TypePath + MaybeTyped + RegisterForReflection, T: TypePath,

impl<T> PartialReflect for AnimatableKeyframeCurve<T>

where AnimatableKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for Arc<T>

where T: Send + Sync + TypePath + ?Sized, Arc<T>: Any + Send + Sync,

impl<T> PartialReflect for ArcMutexValue<T>

where T: Asset + TypePath, ArcMutexValue<T>: Any + Send + Sync,

impl<T> PartialReflect for Axis<T>

where Axis<T>: Any + Send + Sync, T: TypePath, HashMap<T, f32>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ChunkedUnevenCore<T>

where ChunkedUnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ColorCurve<T>

where ColorCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ConstantCurve<T>

where ConstantCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for CubicKeyframeCurve<T>

where CubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for EasingCurve<T>

where EasingCurve<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for EvenCore<T>

where EvenCore<T>: Any + Send + Sync, T: TypePath, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for HandleTemplate<T>

where T: Asset + TypePath, HandleTemplate<T>: Any + Send + Sync, Handle<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ArcMutexValue<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for Interned<T>

where T: Internable + 'static + TypePath + ?Sized, Interned<T>: Any + Send + Sync, &'static T: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for InterpolationDatum<T>

where InterpolationDatum<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for MaybeLocation<T>

where MaybeLocation<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection + ?Sized,

impl<T> PartialReflect for SampleAutoCurve<T>

where SampleAutoCurve<T>: Any + Send + Sync, T: TypePath, EvenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for SteppedKeyframeCurve<T>

where SteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for Time<T>

where T: Default + TypePath + FromReflect + MaybeTyped + RegisterForReflection, Time<T>: Any + Send + Sync,

impl<T> PartialReflect for UnevenCore<T>

where UnevenCore<T>: Any + Send + Sync, T: TypePath, Vec<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for UnevenSampleAutoCurve<T>

where UnevenSampleAutoCurve<T>: Any + Send + Sync, T: TypePath, UnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for ValueChange<T>

where ValueChange<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for Vec<T>

where T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,

impl<T> PartialReflect for VirtualKeyPressed<T>

where VirtualKeyPressed<T>: Any + Send + Sync, T: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for VirtualKeyboard<T>

where T: AsRef<str> + Clone + Send + Sync + 'static + TypePath, VirtualKeyboard<T>: Any + Send + Sync, PhantomData<fn() -> T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WideCubicKeyframeCurve<T>

where WideCubicKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WideLinearKeyframeCurve<T>

where WideLinearKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WideSteppedKeyframeCurve<T>

where WideSteppedKeyframeCurve<T>: Any + Send + Sync, T: TypePath, ChunkedUnevenCore<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WithDerivative<T>

where WithDerivative<T>: Any + Send + Sync, T: HasTangent + TypePath + FromReflect + MaybeTyped + RegisterForReflection, <T as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<T> PartialReflect for WithTwoDerivatives<T>

where WithTwoDerivatives<T>: Any + Send + Sync, T: HasTangent + TypePath + FromReflect + MaybeTyped + RegisterForReflection, <T as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection, <<T as HasTangent>::Tangent as HasTangent>::Tangent: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<V, S> PartialReflect for bevy::platform::collections::HashSet<V, S>

where V: FromReflect + TypePath + GetTypeRegistration + Eq + Hash, S: TypePath + BuildHasher + Default + Send + Sync,

impl<V, W> PartialReflect for Sum<V, W>

where Sum<V, W>: Any + Send + Sync, V: TypePath + FromReflect + MaybeTyped + RegisterForReflection, W: TypePath + FromReflect + MaybeTyped + RegisterForReflection,

impl<V> PartialReflect for EntityHashMap<V>

where EntityHashMap<V>: Any + Send + Sync, V: TypePath, HashMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

impl<V> PartialReflect for EntityIndexMap<V>

where EntityIndexMap<V>: Any + Send + Sync, V: TypePath, IndexMap<Entity, V, EntityHash>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,