From 93d4920477143b131dc6202b2cd8efbeae9c583b Mon Sep 17 00:00:00 2001 From: Dmitry Stepanov Date: Sat, 16 May 2026 19:31:41 +0300 Subject: [PATCH] renamed methods with confusing naming + docs --- editor/src/plugins/absm/mod.rs | 12 +++---- editor/src/plugins/animation/track.rs | 10 +++--- editor/src/plugins/inspector/mod.rs | 4 +-- editor/src/scene/commands/mod.rs | 2 +- editor/src/ui_scene/commands/widget.rs | 2 +- fyrox-animation/src/value.rs | 4 +-- fyrox-core-derive/src/reflect.rs | 10 +++--- fyrox-core/src/dyntype.rs | 10 +++--- fyrox-core/src/pool/handle.rs | 10 +++--- fyrox-core/src/pool/mod.rs | 10 +++--- fyrox-core/src/reflect/impls.rs | 28 ++++++++------- fyrox-core/src/reflect/macros.rs | 48 +++++++++++++------------- fyrox-core/src/reflect/mod.rs | 43 +++++++++++++---------- fyrox-core/src/variable.rs | 22 ++++++------ fyrox-graph/src/lib.rs | 46 ++++++++++++------------ fyrox-impl/src/engine/mod.rs | 2 +- fyrox-impl/src/scene/graph/mod.rs | 2 +- fyrox-impl/src/scene/node/mod.rs | 22 ++++++------ fyrox-impl/src/script/mod.rs | 32 ++++++++--------- fyrox-resource/src/graph.rs | 2 +- fyrox-resource/src/state.rs | 18 +++++----- fyrox-ui/src/inspector/mod.rs | 18 ++++------ fyrox-ui/src/node/mod.rs | 22 ++++++------ 23 files changed, 191 insertions(+), 188 deletions(-) diff --git a/editor/src/plugins/absm/mod.rs b/editor/src/plugins/absm/mod.rs index a81decea9..5c610427f 100644 --- a/editor/src/plugins/absm/mod.rs +++ b/editor/src/plugins/absm/mod.rs @@ -148,7 +148,7 @@ where .try_get_node_mut(absm_handle) .ok() .and_then(|n| { - n.as_reflect_mut_direct() + n.inner_mut_direct() .first_field_mut::>>>() }) .map(|v| v.get_value_mut_silent()) @@ -167,13 +167,13 @@ where let absm = graph.try_get_node(absm_handle).ok()?; let animation_player_handle = **absm - .as_reflect_direct() + .inner_ref_direct() .first_field_ref::>>()?; let animation_player = graph.try_get_mut(animation_player_handle).ok()?; let container = animation_player - .as_reflect_mut_direct() + .inner_mut_direct() .first_field_mut::>>>()?; Some((animation_player_handle, container.get_value_mut_silent())) @@ -188,7 +188,7 @@ where .try_get_node(absm_handle) .ok() .and_then(|n| { - n.as_reflect_direct() + n.inner_ref_direct() .first_field_ref::>>>() }) .map(|v| v.get_value_ref()) @@ -207,13 +207,13 @@ where let absm = graph.try_get_node(absm_handle).ok()?; let animation_player_handle = **absm - .as_reflect_direct() + .inner_ref_direct() .first_field_ref::>>()?; let animation_player = graph.try_get(animation_player_handle).ok()?; let container = animation_player - .as_reflect_direct() + .inner_ref_direct() .first_field_ref::>>>()?; Some((animation_player_handle, &**container)) diff --git a/editor/src/plugins/animation/track.rs b/editor/src/plugins/animation/track.rs index 102d0fa9d..c290d259a 100644 --- a/editor/src/plugins/animation/track.rs +++ b/editor/src/plugins/animation/track.rs @@ -869,7 +869,7 @@ impl TrackList { } ValueBinding::Property { name, .. } => node_ref.find_field(name, &mut |value| { if let Some(value) = value { - value.as_reflect(&mut |reflect| { + value.inner_ref(&mut |reflect| { let curves = track.data_container().curves_ref(); if curves.len() == 1 { if let Some(scalar) = any_scalar_to_f32(reflect) { @@ -1105,7 +1105,7 @@ impl TrackList { Ok(property) => { let mut property_type = TypeId::of::(); property - .as_reflect(&mut |reflect| property_type = reflect.type_id()); + .inner_ref(&mut |reflect| property_type = reflect.type_id()); let types = type_id_to_supported_type(property_type); @@ -1279,7 +1279,7 @@ impl TrackList { { let mut descriptors = Vec::new(); if let Ok(node) = graph.try_get_node(node) { - node.as_reflect(&mut |node| { + node.inner_ref(&mut |node| { descriptors = object_to_property_tree("", node, &mut |field: &FieldRef| { let type_id = field.value.field_value_as_reflect().type_id(); type_id != TypeId::of::() @@ -1411,7 +1411,7 @@ impl TrackList { node.resolve_path(&desc.path, &mut |result| match result { Ok(property) => { let mut property_type = TypeId::of::(); - property.as_reflect(&mut |reflect| property_type = reflect.type_id()); + property.inner_ref(&mut |reflect| property_type = reflect.type_id()); let types = type_id_to_supported_type(property_type); @@ -1714,7 +1714,7 @@ impl TrackList { target.resolve_path(name, &mut |result| match result { Ok(value) => { let mut property_type = TypeId::of::(); - value.as_reflect(&mut |reflect| property_type = reflect.type_id()); + value.inner_ref(&mut |reflect| property_type = reflect.type_id()); if let Some((_, type_)) = type_id_to_supported_type(property_type) { if *value_type != type_ { diff --git a/editor/src/plugins/inspector/mod.rs b/editor/src/plugins/inspector/mod.rs index 6659612db..5539f33bb 100644 --- a/editor/src/plugins/inspector/mod.rs +++ b/editor/src/plugins/inspector/mod.rs @@ -494,8 +494,8 @@ impl EditorPlugin for InspectorPlugin { can_clone = property.try_clone_box().is_some(); if let Some(value) = self.clipboard.as_ref() { - value.as_reflect(&mut |reflect| { - property.as_reflect(&mut |property| { + value.inner_ref(&mut |reflect| { + property.inner_ref(&mut |property| { can_paste = property.type_id() == reflect.type_id(); }) diff --git a/editor/src/scene/commands/mod.rs b/editor/src/scene/commands/mod.rs index 93bc357a5..47356beed 100644 --- a/editor/src/scene/commands/mod.rs +++ b/editor/src/scene/commands/mod.rs @@ -338,7 +338,7 @@ impl CommandTrait for RevertSceneNodePropertyCommand { // If the property was modified, then simply set it to previous value to make it modified again. if let Some(old_value) = self.value.take() { let mut old_value = Some(old_value); - context.scene.graph[self.handle].as_reflect_mut(&mut |node| { + context.scene.graph[self.handle].inner_mut(&mut |node| { node.set_field_by_path(&self.path, old_value.take().unwrap(), &mut |result| { if result.is_err() { Log::err(format!( diff --git a/editor/src/ui_scene/commands/widget.rs b/editor/src/ui_scene/commands/widget.rs index 2b43cd540..f9eb8c916 100644 --- a/editor/src/ui_scene/commands/widget.rs +++ b/editor/src/ui_scene/commands/widget.rs @@ -108,7 +108,7 @@ impl CommandTrait for RevertWidgetPropertyCommand { .get_mut::() .ui .node_mut(self.handle) - .as_reflect_mut(&mut |node| { + .inner_mut(&mut |node| { node.set_field_by_path(&self.path, old_value.take().unwrap(), &mut |result| { if result.is_err() { Log::err(format!( diff --git a/fyrox-animation/src/value.rs b/fyrox-animation/src/value.rs index e99741285..b502b451c 100644 --- a/fyrox-animation/src/value.rs +++ b/fyrox-animation/src/value.rs @@ -405,11 +405,11 @@ impl BoundValue { property_path: &str, value_type: ValueType, ) { - object.as_reflect_mut(&mut |object_ref| { + object.inner_mut(&mut |object_ref| { object_ref.resolve_path_mut(property_path, &mut |result| match result { Ok(property) => { let mut applied = false; - property.as_reflect_mut(&mut |reflect| { + property.inner_mut(&mut |reflect| { applied = self.value.apply_to_any(reflect, value_type); }); if applied { diff --git a/fyrox-core-derive/src/reflect.rs b/fyrox-core-derive/src/reflect.rs index 13bfb4134..00f1ff15e 100644 --- a/fyrox-core-derive/src/reflect.rs +++ b/fyrox-core-derive/src/reflect.rs @@ -477,7 +477,7 @@ fn gen_impl( #metadata_mut } - fn into_inner_reflect(self: Box) -> Box { + fn into_inner(self: Box) -> Box { self } @@ -504,19 +504,19 @@ fn gen_impl( #set_field - fn as_reflect_direct(&self) -> &dyn Reflect { + fn inner_ref_direct(&self) -> &dyn Reflect { self } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { func(self as &dyn Reflect) } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { self } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { func(self as &mut dyn Reflect) } diff --git a/fyrox-core/src/dyntype.rs b/fyrox-core/src/dyntype.rs index 720ccf118..cf7b99ddf 100644 --- a/fyrox-core/src/dyntype.rs +++ b/fyrox-core/src/dyntype.rs @@ -201,15 +201,15 @@ impl Reflect for DynTypeWrapper { }]) } - fn into_inner_reflect(self: Box) -> Box { + fn into_inner(self: Box) -> Box { self } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { func(self) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { func(self) } @@ -244,11 +244,11 @@ impl Reflect for DynTypeWrapper { } } - fn as_reflect_direct(&self) -> &dyn Reflect { + fn inner_ref_direct(&self) -> &dyn Reflect { self } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { self } } diff --git a/fyrox-core/src/pool/handle.rs b/fyrox-core/src/pool/handle.rs index 94b805ef3..458f48c86 100644 --- a/fyrox-core/src/pool/handle.rs +++ b/fyrox-core/src/pool/handle.rs @@ -163,15 +163,15 @@ impl Reflect for Handle { ]) } - fn into_inner_reflect(self: Box) -> Box { + fn into_inner(self: Box) -> Box { self } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { func(self) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { func(self) } @@ -220,11 +220,11 @@ impl Reflect for Handle { } } - fn as_reflect_direct(&self) -> &dyn Reflect { + fn inner_ref_direct(&self) -> &dyn Reflect { self } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { self } } diff --git a/fyrox-core/src/pool/mod.rs b/fyrox-core/src/pool/mod.rs index ac9f18c67..72f2d4e4f 100644 --- a/fyrox-core/src/pool/mod.rs +++ b/fyrox-core/src/pool/mod.rs @@ -177,25 +177,25 @@ where } #[inline] - fn into_inner_reflect(self: Box) -> Box { + fn into_inner(self: Box) -> Box { self } - fn as_reflect_direct(&self) -> &dyn Reflect { + fn inner_ref_direct(&self) -> &dyn Reflect { self } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { self } #[inline] - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { func(self) } #[inline] - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { func(self) } diff --git a/fyrox-core/src/reflect/impls.rs b/fyrox-core/src/reflect/impls.rs index f1119013a..2d421717e 100644 --- a/fyrox-core/src/reflect/impls.rs +++ b/fyrox-core/src/reflect/impls.rs @@ -163,27 +163,27 @@ macro_rules! impl_reflect_inner_mutability { guard.fields_mut(func) } - fn into_inner_reflect($self: Box) -> Box { + fn into_inner($self: Box) -> Box { let inner = $into_inner; Box::new(inner) } - fn as_reflect(&$self, func: &mut dyn FnMut(&dyn Reflect)) { + fn inner_ref(&$self, func: &mut dyn FnMut(&dyn Reflect)) { let guard = $acquire_lock_guard; - (*guard).as_reflect(func) + (*guard).inner_ref(func) } - fn as_reflect_mut(&mut $self, func: &mut dyn FnMut(&mut dyn Reflect)) { + fn inner_mut(&mut $self, func: &mut dyn FnMut(&mut dyn Reflect)) { let mut guard = $acquire_lock_guard; - (*guard).as_reflect_mut(func) + (*guard).inner_mut(func) } - fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect { + fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect { // xxx_direct methods cannot hold the lock, so return self here. self } - fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { // xxx_direct methods cannot hold the lock, so return self here. self } @@ -270,23 +270,27 @@ macro_rules! impl_reflect_inner_mutability { } impl Reflect for parking_lot::Mutex { - impl_reflect_inner_mutability!(self, { self.safe_lock() }, { self.into_inner() }); + impl_reflect_inner_mutability!(self, { self.safe_lock() }, { + parking_lot::Mutex::into_inner(*self) + }); } impl Reflect for parking_lot::RwLock { - impl_reflect_inner_mutability!(self, { self.write() }, { self.into_inner() }); + impl_reflect_inner_mutability!(self, { self.write() }, { + parking_lot::RwLock::into_inner(*self) + }); } #[allow(clippy::mut_mutex_lock)] impl Reflect for std::sync::Mutex { impl_reflect_inner_mutability!(self, { self.safe_lock().unwrap() }, { - self.into_inner().unwrap() + std::sync::Mutex::into_inner(*self).unwrap() }); } impl Reflect for std::sync::RwLock { impl_reflect_inner_mutability!(self, { self.write().unwrap() }, { - self.into_inner().unwrap() + std::sync::RwLock::into_inner(*self).unwrap() }); } @@ -325,7 +329,7 @@ impl Reflect for Arc> { } impl Reflect for RefCell { - impl_reflect_inner_mutability!(self, { self.borrow_mut() }, { self.into_inner() }); + impl_reflect_inner_mutability!(self, { self.borrow_mut() }, { RefCell::into_inner(*self) }); } impl Reflect for Rc> { diff --git a/fyrox-core/src/reflect/macros.rs b/fyrox-core/src/reflect/macros.rs index 58f108e9b..03e2de851 100644 --- a/fyrox-core/src/reflect/macros.rs +++ b/fyrox-core/src/reflect/macros.rs @@ -45,12 +45,12 @@ macro_rules! newtype_reflect { self.0.as_any_mut(func) } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { - self.0.as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { + self.0.inner_ref(func) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { - self.0.as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { + self.0.inner_mut(func) } fn set( @@ -173,24 +173,24 @@ macro_rules! delegate_reflect { self.deref_mut().fields_mut(func) } - fn into_inner_reflect(self: Box) -> Box { - (*self).into_inner_reflect() + fn into_inner(self: Box) -> Box { + (*self).into_inner() } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { - self.deref().as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { + self.deref().inner_ref(func) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { - self.deref_mut().as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { + self.deref_mut().inner_mut(func) } - fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect { - self.deref().as_reflect_direct() + fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect { + self.deref().inner_ref_direct() } - fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { - self.deref_mut().as_reflect_mut_direct() + fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { + self.deref_mut().inner_mut_direct() } fn field_direct_ref(&self, index: usize) -> Option { @@ -318,23 +318,23 @@ macro_rules! blank_reflect { func(&mut []) } - fn into_inner_reflect(self: Box) -> Box { + fn into_inner(self: Box) -> Box { self } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { + fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { func(self) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { func(self) } - fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect { + fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect { self } - fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { self } @@ -402,15 +402,15 @@ macro_rules! blank_reflect_ref { func(&mut []) } - fn into_inner_reflect(self: Box) -> Box { + fn into_inner(self: Box) -> Box { self } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { + fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) { func(self) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) { func(self) } @@ -446,11 +446,11 @@ macro_rules! blank_reflect_ref { Ok(Box::new(this)) } - fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect { + fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect { self } - fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect { self } }; diff --git a/fyrox-core/src/reflect/mod.rs b/fyrox-core/src/reflect/mod.rs index e1b04ce3b..1d1d8bf4b 100644 --- a/fyrox-core/src/reflect/mod.rs +++ b/fyrox-core/src/reflect/mod.rs @@ -155,27 +155,34 @@ pub trait Reflect: Any + Debug { Self: Sized; /// Returns the info about the type that implements this trait. The result of the call of this - /// method can be different from the call of [`Self::type_info`]. + /// method can be different from the call of [`Self::type_info`]. This may happen if the type + /// that implements the trait is a wrapper type. fn type_info_ref(&self) -> TypeInfo; + /// Tries to clone the object and return it as a boxed trait object. This method can return + /// [`None`] for non-cloneable objects. fn try_clone_box(&self) -> Option>; + /// Calls the given closure with the reference to a slice that contains description for all + /// fields in the object. fn fields_ref(&self, func: &mut dyn FnMut(&[FieldRef])); + /// Calls the given closure with the reference to a slice that contains description for all + /// fields in the object. fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [FieldMut])); /// Extracts the wrapped value as `Box` and returns it to the caller. This method /// is intended to be used for wrapper structures only. Any other type should return `self` as /// usual. - fn into_inner_reflect(self: Box) -> Box; + fn into_inner(self: Box) -> Box; - fn as_reflect_direct(&self) -> &dyn Reflect; + fn inner_ref_direct(&self) -> &dyn Reflect; - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect; + fn inner_mut_direct(&mut self) -> &mut dyn Reflect; - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)); + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)); - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)); + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)); fn set(&mut self, value: Box) -> Result, Box>; @@ -304,9 +311,7 @@ pub trait Reflect: Any + Debug { impl dyn Reflect { pub fn downcast(self: Box) -> Result, Box> { if self.is::() { - Ok((self.into_inner_reflect() as Box) - .downcast() - .unwrap()) + Ok((self.into_inner() as Box).downcast().unwrap()) } else { Err(self) } @@ -323,22 +328,22 @@ impl dyn Reflect { #[inline] pub fn downcast_ref(&self, func: &mut dyn FnMut(Option<&T>)) { - self.as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref::())) + self.inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref::())) } #[inline] pub fn downcast_mut(&mut self, func: &mut dyn FnMut(Option<&mut T>)) { - self.as_reflect_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut::())) + self.inner_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut::())) } /// Tries to find the first field of the given type. This method internally uses /// [`Reflect::field_direct_ref`] with all of its limitations. #[inline] pub fn first_field_ref(&self) -> Option<&T> { - let count = self.as_reflect_direct().fields_count(); + let count = self.inner_ref_direct().fields_count(); for i in 0..count { - if let Some(field) = self.as_reflect_direct().field_direct_ref(i) { + if let Some(field) = self.inner_ref_direct().field_direct_ref(i) { if let Some(typed_field) = (field.value as &dyn Any).downcast_ref::() { return Some(typed_field); } @@ -352,7 +357,7 @@ impl dyn Reflect { /// [`Reflect::field_direct_ref`] with all of its limitations. #[inline] pub fn first_field_mut(&mut self) -> Option<&mut T> { - let count = self.as_reflect_direct().fields_count(); + let count = self.inner_ref_direct().fields_count(); for i in 0..count { // SAFETY: Current implementation of borrow checker is just dumb. When a reborrow of self @@ -360,7 +365,7 @@ impl dyn Reflect { // This way the returned reference has a different lifetime than in the method definition. // The following unsafe block reborrows self with the correct lifetime, while the initial // reference is not used so this is absolutely safe. - let this = unsafe { &mut *(self as *mut Self) }.as_reflect_mut_direct(); + let this = unsafe { &mut *(self as *mut Self) }.inner_mut_direct(); if let Some(field) = this.field_direct_mut(i) { if let Some(typed_field) = (field.value as &mut dyn Any).downcast_mut::() { return Some(typed_field); @@ -374,7 +379,7 @@ impl dyn Reflect { /// Tries to downcast self to the specified type, or if it is not possible, tries to find a /// field of the specified type. pub fn self_or_field_ref(&self) -> Option<&T> { - if let Some(value) = (self.as_reflect_direct() as &dyn Any).downcast_ref::() { + if let Some(value) = (self.inner_ref_direct() as &dyn Any).downcast_ref::() { Some(value) } else { self.first_field_ref() @@ -386,7 +391,7 @@ impl dyn Reflect { pub fn self_or_field_mut(&mut self) -> Option<&mut T> { // SAFETY: See the comment in `first_field_mut_of_type` method. let this = unsafe { &mut *(self as *mut Self) }; - if let Some(value) = (self.as_reflect_mut_direct() as &mut dyn Any).downcast_mut::() { + if let Some(value) = (self.inner_mut_direct() as &mut dyn Any).downcast_mut::() { Some(value) } else { this.first_field_mut() @@ -792,7 +797,7 @@ impl GetField for R { self.find_field(name, &mut |opt_field| match opt_field { None => func(None), Some(field) => { - field.as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref())) + field.inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref())) } }) } @@ -801,7 +806,7 @@ impl GetField for R { self.find_field_mut(name, &mut |opt_field| match opt_field { None => func(None), Some(field) => { - field.as_reflect_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut())) + field.inner_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut())) } }) } diff --git a/fyrox-core/src/variable.rs b/fyrox-core/src/variable.rs index 6348c4a69..31b3cad6b 100644 --- a/fyrox-core/src/variable.rs +++ b/fyrox-core/src/variable.rs @@ -439,18 +439,18 @@ where } #[inline] - fn into_inner_reflect(self: Box) -> Box { - Box::new(self.value).into_inner_reflect() + fn into_inner(self: Box) -> Box { + Box::new(self.value).into_inner() } #[inline] - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { - self.value.as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { + self.value.inner_ref(func) } #[inline] - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { - self.value.as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + self.value.inner_mut(func) } #[inline] @@ -535,15 +535,15 @@ where } #[inline] - fn as_reflect_direct(&self) -> &dyn Reflect { - self.value.as_reflect_direct() + fn inner_ref_direct(&self) -> &dyn Reflect { + self.value.inner_ref_direct() } #[inline] - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { // Any modifications inside of inheritable lists must mark the variable as modified. self.mark_modified_and_need_sync(); - self.value.as_reflect_mut_direct() + self.value.inner_mut_direct() } } @@ -608,7 +608,7 @@ where #[inline] fn value_equals(&self, other: &dyn ReflectInheritableVariable) -> bool { let mut output_result = false; - other.as_reflect(&mut |reflect| { + other.inner_ref(&mut |reflect| { reflect.downcast_ref::(&mut |result| { output_result = match result { Some(other) => &self.value == other, diff --git a/fyrox-graph/src/lib.rs b/fyrox-graph/src/lib.rs index 176804708..9fe5842d4 100644 --- a/fyrox-graph/src/lib.rs +++ b/fyrox-graph/src/lib.rs @@ -202,7 +202,7 @@ where #[inline] pub fn remap_handles(&self, node: &mut N, ignored_types: &[TypeId]) { let name = node.name().to_string(); - node.as_reflect_mut(&mut |node| self.remap_handles_any(node, &name, ignored_types)); + node.inner_mut(&mut |node| self.remap_handles_any(node, &name, ignored_types)); } pub fn remap_handles_any( @@ -309,9 +309,7 @@ where field_info_mut .value .field_value_as_reflect_mut() - .as_reflect_mut(&mut |field| { - self.remap_handles_any(field, node_name, ignored_types) - }) + .inner_mut(&mut |field| self.remap_handles_any(field, node_name, ignored_types)) } }) } @@ -319,7 +317,7 @@ where #[inline] pub fn remap_inheritable_handles(&self, node: &mut N, ignored_types: &[TypeId]) { let name = node.name().to_string(); - node.as_reflect_mut(&mut |node| { + node.inner_mut(&mut |node| { self.remap_inheritable_handles_internal(node, &name, false, ignored_types) }); } @@ -463,7 +461,7 @@ where } fn reset_property_modified_flag(entity: &mut dyn Reflect, path: &str) { - entity.as_reflect_mut(&mut |entity| { + entity.inner_mut(&mut |entity| { entity.resolve_path_mut(path, &mut |result| { variable::mark_inheritable_properties_non_modified( result.unwrap(), @@ -566,7 +564,7 @@ pub trait SceneGraphNode: Reflect + NameProvider + Clone + 'static { let mut parent_value = None; // Find and clone parent's value first. - parent.as_reflect(&mut |parent| { + parent.inner_ref(&mut |parent| { parent.resolve_path(path, &mut |result| match result { Ok(parent_field) => parent_field.as_inheritable_variable(&mut |parent_field| { if let Some(parent_inheritable) = parent_field { @@ -582,7 +580,7 @@ pub trait SceneGraphNode: Reflect + NameProvider + Clone + 'static { // Check whether the child's field is inheritable and modified. let mut need_revert = false; - self.as_reflect_mut(&mut |child| { + self.inner_mut(&mut |child| { child.resolve_path_mut(path, &mut |result| match result { Ok(child_field) => { child_field.as_inheritable_variable_mut(&mut |child_inheritable| { @@ -605,7 +603,7 @@ pub trait SceneGraphNode: Reflect + NameProvider + Clone + 'static { let mut was_set = false; let mut parent_value = Some(parent_value); - self.as_reflect_mut(&mut |child| { + self.inner_mut(&mut |child| { child.set_field_by_path( path, parent_value.take().unwrap(), @@ -1389,8 +1387,8 @@ pub trait SceneGraph: 'static { // Check if the actual node types (this and parent's) are equal, and if not - copy the // node and replace its base. let mut types_match = true; - node.as_reflect(&mut |node_reflect| { - resource_node.as_reflect(&mut |resource_node_reflect| { + node.inner_ref(&mut |node_reflect| { + resource_node.inner_ref(&mut |resource_node_reflect| { types_match = node_reflect.type_id() == resource_node_reflect.type_id(); @@ -1419,8 +1417,8 @@ pub trait SceneGraph: 'static { } // Then try to inherit properties. - node.as_reflect_mut(&mut |node_reflect| { - resource_node.as_reflect(&mut |resource_node_reflect| { + node.inner_mut(&mut |node_reflect| { + resource_node.inner_ref(&mut |resource_node_reflect| { Log::verify(variable::try_inherit_properties( node_reflect, resource_node_reflect, @@ -1754,16 +1752,16 @@ mod test { self.0.deref_mut().fields_mut(func) } - fn into_inner_reflect(self: Box) -> Box { - Reflect::into_inner_reflect(self.0) + fn into_inner(self: Box) -> Box { + Reflect::into_inner(self.0) } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { - self.0.deref().as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { + self.0.deref().inner_ref(func) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { - self.0.deref_mut().as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + self.0.deref_mut().inner_mut(func) } fn set(&mut self, value: Box) -> Result, Box> { @@ -1803,12 +1801,12 @@ mod test { self.0.fields_count() } - fn as_reflect_direct(&self) -> &dyn Reflect { - self.0.as_reflect_direct() + fn inner_ref_direct(&self) -> &dyn Reflect { + self.0.inner_ref_direct() } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { - self.0.as_reflect_mut_direct() + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { + self.0.inner_mut_direct() } } @@ -2324,7 +2322,7 @@ mod test { .unwrap() .transmute::(); let joint_copy = mapping.inner().get(&joint).cloned().unwrap(); - scene_graph.nodes[joint_copy].as_reflect(&mut |reflect| { + scene_graph.nodes[joint_copy].inner_ref(&mut |reflect| { let joint_copy_ref = (reflect as &dyn Any).downcast_ref::().unwrap(); assert_eq!(joint_copy_ref.connected_body1, rigid_body_copy); assert_eq!(joint_copy_ref.connected_body2, rigid_body2_copy); diff --git a/fyrox-impl/src/engine/mod.rs b/fyrox-impl/src/engine/mod.rs index c97961d8a..6961b4b1c 100644 --- a/fyrox-impl/src/engine/mod.rs +++ b/fyrox-impl/src/engine/mod.rs @@ -2641,7 +2641,7 @@ impl Engine { for resource in state.resources().iter() { let data = resource.lock(); if let ResourceState::Ok { ref data, .. } = data.state { - data.as_reflect(&mut |reflect| { + data.inner_ref(&mut |reflect| { if reflect.type_info_ref().assembly_name == plugin_assembly_name { resources_to_reload.insert(resource.clone()); } diff --git a/fyrox-impl/src/scene/graph/mod.rs b/fyrox-impl/src/scene/graph/mod.rs index 68eb27d83..3ce6dbf64 100644 --- a/fyrox-impl/src/scene/graph/mod.rs +++ b/fyrox-impl/src/scene/graph/mod.rs @@ -538,7 +538,7 @@ impl Graph { for (node_handle, node) in self.pair_iter() { (node as &dyn Reflect).apply_recursively( &mut |object| { - object.as_reflect(&mut |reflect| { + object.inner_ref(&mut |reflect| { if let Some(handle) = (reflect as &dyn Any).downcast_ref::>() { if *handle == target { references.push(node_handle); diff --git a/fyrox-impl/src/scene/node/mod.rs b/fyrox-impl/src/scene/node/mod.rs index 0a6e9e38c..ced10630a 100644 --- a/fyrox-impl/src/scene/node/mod.rs +++ b/fyrox-impl/src/scene/node/mod.rs @@ -532,7 +532,7 @@ impl Node { // Reset inheritable properties, so property inheritance system will take properties // from parent objects on resolve stage. - self.as_reflect_mut(&mut |reflect| { + self.inner_mut(&mut |reflect| { mark_inheritable_properties_non_modified(reflect, &[TypeId::of::()]) }); @@ -601,16 +601,16 @@ impl Reflect for Node { self.0.deref_mut().fields_mut(func) } - fn into_inner_reflect(self: Box) -> Box { - Reflect::into_inner_reflect(self.0) + fn into_inner(self: Box) -> Box { + Reflect::into_inner(self.0) } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { - self.0.deref().as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { + self.0.deref().inner_ref(func) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { - self.0.deref_mut().as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + self.0.deref_mut().inner_mut(func) } fn set(&mut self, value: Box) -> Result, Box> { @@ -646,12 +646,12 @@ impl Reflect for Node { self.0.deref_mut().field_direct_mut(index) } - fn as_reflect_direct(&self) -> &dyn Reflect { - self.0.as_reflect_direct() + fn inner_ref_direct(&self) -> &dyn Reflect { + self.0.inner_ref_direct() } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { - self.0.as_reflect_mut_direct() + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { + self.0.inner_mut_direct() } } diff --git a/fyrox-impl/src/script/mod.rs b/fyrox-impl/src/script/mod.rs index 3affe5c85..6cd8beef6 100644 --- a/fyrox-impl/src/script/mod.rs +++ b/fyrox-impl/src/script/mod.rs @@ -754,16 +754,16 @@ impl Reflect for Script { self.instance.fields_mut(func) } - fn into_inner_reflect(self: Box) -> Box { - self.instance.into_inner_reflect() + fn into_inner(self: Box) -> Box { + self.instance.into_inner() } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { - self.instance.deref().as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { + self.instance.deref().inner_ref(func) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { - self.instance.deref_mut().as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + self.instance.deref_mut().inner_mut(func) } fn set(&mut self, value: Box) -> Result, Box> { @@ -806,12 +806,12 @@ impl Reflect for Script { self.instance.deref_mut().field_direct_mut(index) } - fn as_reflect_direct(&self) -> &dyn Reflect { - self.instance.as_reflect_direct() + fn inner_ref_direct(&self) -> &dyn Reflect { + self.instance.inner_ref_direct() } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { - self.instance.as_reflect_mut_direct() + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { + self.instance.inner_mut_direct() } } @@ -958,8 +958,8 @@ mod test { field: InheritableVariable::new_non_modified(3.21), }))); - child.as_reflect_mut(&mut |child| { - parent.as_reflect(&mut |parent| { + child.inner_mut(&mut |child| { + parent.inner_ref(&mut |parent| { try_inherit_properties(child, parent, &[]).unwrap(); }) }); @@ -980,8 +980,8 @@ mod test { field: InheritableVariable::new_non_modified(3.21), }); - child.as_reflect_mut(&mut |child| { - parent.as_reflect(&mut |parent| { + child.inner_mut(&mut |child| { + parent.inner_ref(&mut |parent| { try_inherit_properties(child, parent, &[]).unwrap(); }) }); @@ -999,8 +999,8 @@ mod test { field: InheritableVariable::new_non_modified(3.21), })); - child.as_reflect_mut(&mut |child| { - parent.as_reflect(&mut |parent| { + child.inner_mut(&mut |child| { + parent.inner_ref(&mut |parent| { try_inherit_properties(child, parent, &[]).unwrap(); }) }); diff --git a/fyrox-resource/src/graph.rs b/fyrox-resource/src/graph.rs index 43ade6712..31e629909 100644 --- a/fyrox-resource/src/graph.rs +++ b/fyrox-resource/src/graph.rs @@ -42,7 +42,7 @@ impl ResourceGraphNode { let header = resource.lock(); if let ResourceState::Ok { ref data, .. } = header.state { - (**data).as_reflect(&mut |entity| { + (**data).inner_ref(&mut |entity| { collect_used_resources(entity, &mut dependent_resources); }); } diff --git a/fyrox-resource/src/state.rs b/fyrox-resource/src/state.rs index 785161220..aa9a38b94 100644 --- a/fyrox-resource/src/state.rs +++ b/fyrox-resource/src/state.rs @@ -121,24 +121,24 @@ impl Reflect for ResourceDataWrapper { self.deref_mut().fields_mut(func) } - fn into_inner_reflect(self: Box) -> Box { + fn into_inner(self: Box) -> Box { self } - fn as_reflect_direct(&self) -> &dyn Reflect { - self.deref().as_reflect_direct() + fn inner_ref_direct(&self) -> &dyn Reflect { + self.deref().inner_ref_direct() } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { - self.deref_mut().as_reflect_mut_direct() + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { + self.deref_mut().inner_mut_direct() } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { - self.deref().as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { + self.deref().inner_ref(func) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { - self.deref_mut().as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + self.deref_mut().inner_mut(func) } fn set(&mut self, value: Box) -> Result, Box> { diff --git a/fyrox-ui/src/inspector/mod.rs b/fyrox-ui/src/inspector/mod.rs index ed1e23732..1413f5da4 100644 --- a/fyrox-ui/src/inspector/mod.rs +++ b/fyrox-ui/src/inspector/mod.rs @@ -260,11 +260,7 @@ where } fn into_box_reflect(self: Box) -> Box { - Box::new( - *(self.into_inner_reflect() as Box) - .downcast::() - .unwrap(), - ) + Box::new(*(self.into_inner() as Box).downcast::().unwrap()) } } @@ -295,17 +291,17 @@ impl PartialEq for ObjectValue { impl ObjectValue { pub fn cast_value(&self, func: &mut dyn FnMut(Option<&T>)) { - (*self.value).as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref::())) + (*self.value).inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref::())) } pub fn cast_clone(&self, func: &mut dyn FnMut(Option)) { (*self.value) - .as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref::().cloned())) + .inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref::().cloned())) } pub fn try_override(&self, value: &mut T) -> bool { let mut result = false; - (*self.value).as_reflect(&mut |reflect| { + (*self.value).inner_ref(&mut |reflect| { if let Some(self_value) = (reflect as &dyn Any).downcast_ref::() { *value = self_value.clone(); result = true; @@ -587,8 +583,8 @@ impl Inspector { can_clone = field.try_clone_box().is_some(); if let Some(clipboard_value) = clipboard_value { - clipboard_value.as_reflect(&mut |clipboard_value| { - field.as_reflect(&mut |field| { + clipboard_value.inner_ref(&mut |clipboard_value| { + field.inner_ref(&mut |field| { can_paste = field.type_id() == clipboard_value.type_id(); }) }); @@ -848,7 +844,7 @@ impl PartialEq for InspectorContext { fn object_type_id(object: &dyn Reflect) -> TypeId { let mut object_type_id = None; - object.as_reflect(&mut |reflect| object_type_id = Some(reflect.type_id())); + object.inner_ref(&mut |reflect| object_type_id = Some(reflect.type_id())); object_type_id.unwrap() } diff --git a/fyrox-ui/src/node/mod.rs b/fyrox-ui/src/node/mod.rs index 53c01cada..e2c29f69d 100644 --- a/fyrox-ui/src/node/mod.rs +++ b/fyrox-ui/src/node/mod.rs @@ -247,7 +247,7 @@ impl UiNode { // Reset inheritable properties, so property inheritance system will take properties // from parent objects on resolve stage. - self.as_reflect_mut(&mut |reflect| { + self.inner_mut(&mut |reflect| { variable::mark_inheritable_properties_non_modified( reflect, &[TypeId::of::()], @@ -299,24 +299,24 @@ impl Reflect for UiNode { self.0.deref_mut().fields_mut(func) } - fn into_inner_reflect(self: Box) -> Box { - Reflect::into_inner_reflect(self.0) + fn into_inner(self: Box) -> Box { + Reflect::into_inner(self.0) } - fn as_reflect_direct(&self) -> &dyn Reflect { - self.0.deref().as_reflect_direct() + fn inner_ref_direct(&self) -> &dyn Reflect { + self.0.deref().inner_ref_direct() } - fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect { - self.0.deref_mut().as_reflect_mut_direct() + fn inner_mut_direct(&mut self) -> &mut dyn Reflect { + self.0.deref_mut().inner_mut_direct() } - fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) { - self.0.deref().as_reflect(func) + fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) { + self.0.deref().inner_ref(func) } - fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { - self.0.deref_mut().as_reflect_mut(func) + fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) { + self.0.deref_mut().inner_mut(func) } fn set(&mut self, value: Box) -> Result, Box> {