From 1133584f451d0e5df3098900a4f4329fb0b93ce7 Mon Sep 17 00:00:00 2001 From: MrGVSV Date: Mon, 7 Mar 2022 11:35:07 -0800 Subject: [PATCH 1/5] Added ReflectFromReflect --- crates/bevy_reflect/src/from_reflect.rs | 37 +++++++++++++++++++++++ crates/bevy_reflect/src/impls/smallvec.rs | 2 +- crates/bevy_reflect/src/impls/std.rs | 4 +-- crates/bevy_reflect/src/lib.rs | 36 ++++++++++++++++++++++ crates/bevy_reflect/src/reflect.rs | 17 +---------- 5 files changed, 77 insertions(+), 19 deletions(-) create mode 100644 crates/bevy_reflect/src/from_reflect.rs diff --git a/crates/bevy_reflect/src/from_reflect.rs b/crates/bevy_reflect/src/from_reflect.rs new file mode 100644 index 0000000000000..1f6c8c36c5dfa --- /dev/null +++ b/crates/bevy_reflect/src/from_reflect.rs @@ -0,0 +1,37 @@ +use crate::{FromType, Reflect}; + +/// A trait for types which can be constructed from a reflected type. +/// +/// This trait can be derived on types which implement [`Reflect`]. Some complex +/// types (such as `Vec`) may only be reflected if their element types +/// implement this trait. +/// +/// For structs and tuple structs, fields marked with the `#[reflect(ignore)]` +/// attribute will be constructed using the `Default` implementation of the +/// field type, rather than the corresponding field value (if any) of the +/// reflected value. +pub trait FromReflect: Reflect + Sized { + /// Constructs a concrete instance of `Self` from a reflected value. + fn from_reflect(reflect: &dyn Reflect) -> Option; +} + +#[derive(Clone)] +pub struct ReflectFromReflect { + from_reflect: fn(&dyn Reflect) -> Option>, +} + +impl ReflectFromReflect { + pub fn from_reflect(&self, reflect_value: &dyn Reflect) -> Option> { + (self.from_reflect)(reflect_value) + } +} + +impl FromType for ReflectFromReflect { + fn from_type() -> Self { + Self { + from_reflect: |reflect_value| { + T::from_reflect(reflect_value).map(|value| Box::new(value) as Box) + }, + } + } +} \ No newline at end of file diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index 4d6417c6df068..f3e0d0e10b361 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/crates/bevy_reflect/src/impls/smallvec.rs @@ -1,7 +1,7 @@ use smallvec::{Array, SmallVec}; use std::any::Any; -use crate::{serde::Serializable, FromReflect, List, ListIter, Reflect, ReflectMut, ReflectRef}; +use crate::{FromReflect, List, ListIter, Reflect, ReflectMut, ReflectRef, serde::Serializable}; impl List for SmallVec where diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index 0b1d4097e1e11..509bdfc39de83 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -1,7 +1,7 @@ use crate as bevy_reflect; use crate::{ - map_partial_eq, serde::Serializable, DynamicMap, FromReflect, FromType, GetTypeRegistration, - List, ListIter, Map, MapIter, Reflect, ReflectDeserialize, ReflectMut, ReflectRef, + DynamicMap, FromReflect, FromType, GetTypeRegistration, List, ListIter, + Map, map_partial_eq, MapIter, Reflect, ReflectDeserialize, ReflectMut, ReflectRef, serde::Serializable, TypeRegistration, }; diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs index cd479d1e07dec..9e9215145c0cd 100644 --- a/crates/bevy_reflect/src/lib.rs +++ b/crates/bevy_reflect/src/lib.rs @@ -1,5 +1,6 @@ #![doc = include_str!("../README.md")] +mod from_reflect; mod list; mod map; mod path; @@ -24,6 +25,7 @@ mod impls { } pub mod serde; + pub mod prelude { #[doc(hidden)] pub use crate::{ @@ -32,6 +34,7 @@ pub mod prelude { }; } +pub use from_reflect::*; pub use impls::*; pub use list::*; pub use map::*; @@ -49,6 +52,7 @@ pub use erased_serde; #[cfg(test)] #[allow(clippy::blacklisted_name, clippy::approx_constant)] mod tests { + use std::any::TypeId; use ::serde::de::DeserializeSeed; use bevy_utils::HashMap; use ron::{ @@ -423,4 +427,36 @@ mod tests { std::any::type_name::() ); } + + #[test] + fn should_reflect_from_type_id() { + #[derive(Reflect, FromReflect)] + #[reflect(FromReflect)] + struct MyStruct { + foo: usize, + } + + // Register + let mut registry = TypeRegistry::default(); + registry.register::(); + + // Get type data + let type_id = TypeId::of::(); + let rfr = registry + .get_type_data::(type_id) + .expect("the FromReflect trait should be registered"); + + // Call from_reflect + let mut dynamic_struct = DynamicStruct::default(); + dynamic_struct.insert("foo", 123usize); + let reflected = rfr + .from_reflect(&dynamic_struct) + .expect("the type should be properly reflected"); + + // Assert + let expected = MyStruct { foo: 123 }; + assert!(expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + let not_expected = MyStruct { foo: 321 }; + assert!(!not_expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + } } diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 4362068df918e..7496c8f88e1c2 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -1,4 +1,4 @@ -use crate::{serde::Serializable, List, Map, Struct, Tuple, TupleStruct}; +use crate::{List, Map, serde::Serializable, Struct, Tuple, TupleStruct}; use std::{any::Any, fmt::Debug}; pub use bevy_utils::AHasher as ReflectHasher; @@ -135,21 +135,6 @@ pub unsafe trait Reflect: Any + Send + Sync { fn serializable(&self) -> Option; } -/// A trait for types which can be constructed from a reflected type. -/// -/// This trait can be derived on types which implement [`Reflect`]. Some complex -/// types (such as `Vec`) may only be reflected if their element types -/// implement this trait. -/// -/// For structs and tuple structs, fields marked with the `#[reflect(ignore)]` -/// attribute will be constructed using the `Default` implementation of the -/// field type, rather than the corresponding field value (if any) of the -/// reflected value. -pub trait FromReflect: Reflect + Sized { - /// Constructs a concrete instance of `Self` from a reflected value. - fn from_reflect(reflect: &dyn Reflect) -> Option; -} - impl Debug for dyn Reflect { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "Reflect({})", self.type_name()) From 036fca269c25856993d09cf0828ee8804174152c Mon Sep 17 00:00:00 2001 From: MrGVSV Date: Mon, 7 Mar 2022 11:50:01 -0800 Subject: [PATCH 2/5] Registered ReflectFromReflect for common types --- crates/bevy_reflect/src/impls/glam.rs | 32 ++++++++--------- crates/bevy_reflect/src/impls/std.rs | 48 ++++++++++++------------- crates/bevy_reflect/src/lib.rs | 50 +++++++++++++++++++++++++-- 3 files changed, 87 insertions(+), 43 deletions(-) diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs index cda30156b68ca..f37a103aa5498 100644 --- a/crates/bevy_reflect/src/impls/glam.rs +++ b/crates/bevy_reflect/src/impls/glam.rs @@ -3,22 +3,22 @@ use crate::ReflectDeserialize; use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value}; use glam::*; -impl_reflect_value!(IVec2(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(IVec3(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(IVec4(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(UVec2(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(UVec3(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(UVec4(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Vec2(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Vec3(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Vec3A(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Vec4(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(DVec2(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(DVec3(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(DVec4(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Mat3(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Mat4(PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize)); +impl_reflect_value!(IVec2(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(IVec3(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(IVec4(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(UVec2(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(UVec3(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(UVec4(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Vec2(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Vec3(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Vec3A(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Vec4(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(DVec2(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(DVec3(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(DVec4(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Mat3(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Mat4(PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize, FromReflect)); impl_from_reflect_value!(IVec2); impl_from_reflect_value!(IVec3); diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index 509bdfc39de83..367bf492b3993 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -1,9 +1,5 @@ use crate as bevy_reflect; -use crate::{ - DynamicMap, FromReflect, FromType, GetTypeRegistration, List, ListIter, - Map, map_partial_eq, MapIter, Reflect, ReflectDeserialize, ReflectMut, ReflectRef, serde::Serializable, - TypeRegistration, -}; +use crate::{DynamicMap, FromReflect, FromType, GetTypeRegistration, List, ListIter, Map, map_partial_eq, MapIter, Reflect, ReflectDeserialize, ReflectFromReflect, ReflectMut, ReflectRef, serde::Serializable, TypeRegistration}; use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value}; use bevy_utils::{Duration, HashMap, HashSet}; @@ -15,26 +11,26 @@ use std::{ ops::Range, }; -impl_reflect_value!(bool(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(u8(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(u16(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(u32(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(u64(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(u128(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(usize(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(i8(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(i16(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(i32(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(i64(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(i128(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(isize(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(f32(Serialize, Deserialize)); -impl_reflect_value!(f64(Serialize, Deserialize)); -impl_reflect_value!(String(Hash, PartialEq, Serialize, Deserialize)); -impl_reflect_value!(Option Deserialize<'de> + Reflect + 'static>(Serialize, Deserialize)); -impl_reflect_value!(HashSet Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize)); -impl_reflect_value!(Range Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize)); -impl_reflect_value!(Duration(Hash, PartialEq, Serialize, Deserialize)); +impl_reflect_value!(bool(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(u8(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(u16(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(u32(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(u64(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(u128(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(usize(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(i8(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(i16(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(i32(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(i64(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(i128(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(isize(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(f32(Serialize, Deserialize, FromReflect)); +impl_reflect_value!(f64(Serialize, Deserialize, FromReflect)); +impl_reflect_value!(String(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Option Deserialize<'de> + Reflect + 'static>(Serialize, Deserialize, FromReflect)); +impl_reflect_value!(HashSet Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Range Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Duration(Hash, PartialEq, Serialize, Deserialize, FromReflect)); impl_from_reflect_value!(bool); impl_from_reflect_value!(u8); @@ -148,6 +144,7 @@ impl Deserialize<'de>> GetTypeRegistration for Vec fn get_type_registration() -> TypeRegistration { let mut registration = TypeRegistration::of::>(); registration.insert::(FromType::>::from_type()); + registration.insert::(FromType::>::from_type()); registration } } @@ -355,6 +352,7 @@ impl GetTypeRegistration for Cow<'static, str> { fn get_type_registration() -> TypeRegistration { let mut registration = TypeRegistration::of::>(); registration.insert::(FromType::>::from_type()); + registration.insert::(FromType::>::from_type()); registration } } diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs index 9e9215145c0cd..a6a65e7e4a255 100644 --- a/crates/bevy_reflect/src/lib.rs +++ b/crates/bevy_reflect/src/lib.rs @@ -436,6 +436,7 @@ mod tests { foo: usize, } + // === Struct === // // Register let mut registry = TypeRegistry::default(); registry.register::(); @@ -456,7 +457,52 @@ mod tests { // Assert let expected = MyStruct { foo: 123 }; assert!(expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); - let not_expected = MyStruct { foo: 321 }; - assert!(!not_expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + let unexpected = MyStruct { foo: 321 }; + assert!(!unexpected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + + // === Vec === // + // Register + registry.register::>(); + + // Get type data + let type_id = TypeId::of::>(); + let rfr = registry + .get_type_data::(type_id) + .expect("the FromReflect trait should be registered"); + + // Call from_reflect + let mut dynamic_list = DynamicList::default(); + dynamic_list.push(1usize); + dynamic_list.push(2usize); + dynamic_list.push(3usize); + let reflected = rfr + .from_reflect(&dynamic_list) + .expect("the type should be properly reflected"); + + // Assert + let expected = vec![1usize, 2usize, 3usize]; + assert!(expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + let unexpected = vec![1usize, 2usize, 3usize, 4usize]; + assert!(!unexpected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + + // === Value === // + // Register + registry.register::(); + + // Get type data + let type_id = TypeId::of::(); + let rfr = registry + .get_type_data::(type_id) + .expect("the FromReflect trait should be registered"); + + // Call from_reflect + let dynamic_value: i32 = 123; + let reflected = rfr + .from_reflect(&dynamic_value) + .expect("the type should be properly reflected"); + + // Assert + let expected: i32 = 123; + assert!(expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); } } From cf227eec214e02efd329b7306eeaffd17586e816 Mon Sep 17 00:00:00 2001 From: MrGVSV Date: Mon, 7 Mar 2022 11:54:57 -0800 Subject: [PATCH 3/5] Registered ReflectFromReflect --- crates/bevy_asset/src/handle.rs | 4 ++-- crates/bevy_reflect/src/impls/glam.rs | 2 +- crates/bevy_render/src/color/mod.rs | 4 ++-- crates/bevy_text/src/text.rs | 4 +++- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs index 06fdee6907a37..590dce8ce3ff2 100644 --- a/crates/bevy_asset/src/handle.rs +++ b/crates/bevy_asset/src/handle.rs @@ -10,7 +10,7 @@ use crate::{ Asset, Assets, }; use bevy_ecs::{component::Component, reflect::ReflectComponent}; -use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize}; +use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize, ReflectFromReflect}; use bevy_utils::Uuid; use crossbeam_channel::{Receiver, Sender}; use serde::{Deserialize, Serialize}; @@ -95,7 +95,7 @@ impl HandleId { /// collisions no longer being detected for that entity. /// #[derive(Component, Reflect, FromReflect)] -#[reflect(Component)] +#[reflect(Component, FromReflect)] pub struct Handle where T: Asset, diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs index f37a103aa5498..8a0eaca316760 100644 --- a/crates/bevy_reflect/src/impls/glam.rs +++ b/crates/bevy_reflect/src/impls/glam.rs @@ -1,5 +1,5 @@ use crate as bevy_reflect; -use crate::ReflectDeserialize; +use crate::{ReflectDeserialize, ReflectFromReflect}; use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value}; use glam::*; diff --git a/crates/bevy_render/src/color/mod.rs b/crates/bevy_render/src/color/mod.rs index bdfe03dd44d77..163134b9d68d9 100644 --- a/crates/bevy_render/src/color/mod.rs +++ b/crates/bevy_render/src/color/mod.rs @@ -4,12 +4,12 @@ pub use colorspace::*; use crate::color::{HslRepresentation, SrgbColorSpace}; use bevy_math::{Vec3, Vec4}; -use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize}; +use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize, ReflectFromReflect}; use serde::{Deserialize, Serialize}; use std::ops::{Add, AddAssign, Mul, MulAssign}; #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Reflect, FromReflect)] -#[reflect(PartialEq, Serialize, Deserialize)] +#[reflect(PartialEq, Serialize, Deserialize, FromReflect)] pub enum Color { /// sRGBA color Rgba { diff --git a/crates/bevy_text/src/text.rs b/crates/bevy_text/src/text.rs index 2f2b37ab9a19e..b0957de8d5803 100644 --- a/crates/bevy_text/src/text.rs +++ b/crates/bevy_text/src/text.rs @@ -1,7 +1,7 @@ use bevy_asset::Handle; use bevy_ecs::{prelude::Component, reflect::ReflectComponent}; use bevy_math::Size; -use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize}; +use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize, ReflectFromReflect}; use bevy_render::color::Color; use serde::{Deserialize, Serialize}; @@ -66,6 +66,7 @@ impl Text { } #[derive(Debug, Default, Clone, FromReflect, Reflect)] +#[reflect(FromReflect)] pub struct TextSection { pub value: String, pub style: TextStyle, @@ -135,6 +136,7 @@ impl From for glyph_brush_layout::VerticalAlign { } #[derive(Clone, Debug, Reflect, FromReflect)] +#[reflect(FromReflect)] pub struct TextStyle { pub font: Handle, pub font_size: f32, From e3fbc762889548e00f3e05f48dc1c8fd3ce08f05 Mon Sep 17 00:00:00 2001 From: MrGVSV Date: Mon, 7 Mar 2022 23:22:18 -0800 Subject: [PATCH 4/5] Added trait object test --- crates/bevy_reflect/src/lib.rs | 45 ++++++++++++++++++++++++++++------ 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs index a6a65e7e4a255..e5dff7417dff3 100644 --- a/crates/bevy_reflect/src/lib.rs +++ b/crates/bevy_reflect/src/lib.rs @@ -52,13 +52,13 @@ pub use erased_serde; #[cfg(test)] #[allow(clippy::blacklisted_name, clippy::approx_constant)] mod tests { - use std::any::TypeId; use ::serde::de::DeserializeSeed; use bevy_utils::HashMap; use ron::{ ser::{to_string_pretty, PrettyConfig}, Deserializer, }; + use std::any::TypeId; use super::*; use crate as bevy_reflect; @@ -431,11 +431,22 @@ mod tests { #[test] fn should_reflect_from_type_id() { #[derive(Reflect, FromReflect)] - #[reflect(FromReflect)] + #[reflect(FromReflect, MyTrait)] struct MyStruct { foo: usize, } + #[reflect_trait] + trait MyTrait { + fn foo(&self) -> usize; + } + + impl MyTrait for MyStruct { + fn foo(&self) -> usize { + self.foo + } + } + // === Struct === // // Register let mut registry = TypeRegistry::default(); @@ -456,9 +467,23 @@ mod tests { // Assert let expected = MyStruct { foo: 123 }; - assert!(expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + assert!(expected + .reflect_partial_eq(reflected.as_ref()) + .unwrap_or_default()); let unexpected = MyStruct { foo: 321 }; - assert!(!unexpected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + assert!(!unexpected + .reflect_partial_eq(reflected.as_ref()) + .unwrap_or_default()); + + // --- Traits --- // + let my_trait = registry + .get_type_data::(type_id) + .expect("the trait should be registered"); + let trait_obj = my_trait + .get(reflected.as_ref()) + .expect("the reflected value should be convertable to trait object"); + + assert_eq!(expected.foo, trait_obj.foo()); // === Vec === // // Register @@ -481,9 +506,13 @@ mod tests { // Assert let expected = vec![1usize, 2usize, 3usize]; - assert!(expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + assert!(expected + .reflect_partial_eq(reflected.as_ref()) + .unwrap_or_default()); let unexpected = vec![1usize, 2usize, 3usize, 4usize]; - assert!(!unexpected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + assert!(!unexpected + .reflect_partial_eq(reflected.as_ref()) + .unwrap_or_default()); // === Value === // // Register @@ -503,6 +532,8 @@ mod tests { // Assert let expected: i32 = 123; - assert!(expected.reflect_partial_eq(reflected.as_ref()).unwrap_or_default()); + assert!(expected + .reflect_partial_eq(reflected.as_ref()) + .unwrap_or_default()); } } From 66171283bbc51769b08335c3a696b4e10aa48109 Mon Sep 17 00:00:00 2001 From: MrGVSV Date: Mon, 7 Mar 2022 23:22:34 -0800 Subject: [PATCH 5/5] Formatting --- crates/bevy_reflect/src/from_reflect.rs | 2 +- crates/bevy_reflect/src/impls/smallvec.rs | 2 +- crates/bevy_reflect/src/impls/std.rs | 14 ++++++++++++-- crates/bevy_reflect/src/reflect.rs | 2 +- 4 files changed, 15 insertions(+), 5 deletions(-) diff --git a/crates/bevy_reflect/src/from_reflect.rs b/crates/bevy_reflect/src/from_reflect.rs index 1f6c8c36c5dfa..7e8cc5a8ea723 100644 --- a/crates/bevy_reflect/src/from_reflect.rs +++ b/crates/bevy_reflect/src/from_reflect.rs @@ -34,4 +34,4 @@ impl FromType for ReflectFromReflect { }, } } -} \ No newline at end of file +} diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index f3e0d0e10b361..4d6417c6df068 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/crates/bevy_reflect/src/impls/smallvec.rs @@ -1,7 +1,7 @@ use smallvec::{Array, SmallVec}; use std::any::Any; -use crate::{FromReflect, List, ListIter, Reflect, ReflectMut, ReflectRef, serde::Serializable}; +use crate::{serde::Serializable, FromReflect, List, ListIter, Reflect, ReflectMut, ReflectRef}; impl List for SmallVec where diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index 367bf492b3993..9a953d060cbf2 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -1,5 +1,9 @@ use crate as bevy_reflect; -use crate::{DynamicMap, FromReflect, FromType, GetTypeRegistration, List, ListIter, Map, map_partial_eq, MapIter, Reflect, ReflectDeserialize, ReflectFromReflect, ReflectMut, ReflectRef, serde::Serializable, TypeRegistration}; +use crate::{ + map_partial_eq, serde::Serializable, DynamicMap, FromReflect, FromType, GetTypeRegistration, + List, ListIter, Map, MapIter, Reflect, ReflectDeserialize, ReflectFromReflect, ReflectMut, + ReflectRef, TypeRegistration, +}; use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value}; use bevy_utils::{Duration, HashMap, HashSet}; @@ -30,7 +34,13 @@ impl_reflect_value!(String(Hash, PartialEq, Serialize, Deserialize, FromReflect) impl_reflect_value!(Option Deserialize<'de> + Reflect + 'static>(Serialize, Deserialize, FromReflect)); impl_reflect_value!(HashSet Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize, FromReflect)); impl_reflect_value!(Range Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize, FromReflect)); -impl_reflect_value!(Duration(Hash, PartialEq, Serialize, Deserialize, FromReflect)); +impl_reflect_value!(Duration( + Hash, + PartialEq, + Serialize, + Deserialize, + FromReflect +)); impl_from_reflect_value!(bool); impl_from_reflect_value!(u8); diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 7496c8f88e1c2..d029feb0ba377 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -1,4 +1,4 @@ -use crate::{List, Map, serde::Serializable, Struct, Tuple, TupleStruct}; +use crate::{serde::Serializable, List, Map, Struct, Tuple, TupleStruct}; use std::{any::Any, fmt::Debug}; pub use bevy_utils::AHasher as ReflectHasher;