replace MapEntities impls with IntoIterator

Author: jrobsonchase

crates/bevy_animation/src/lib.rs

@@ -19,7 +19,7 @@ use std::{
     collections::BTreeMap,
     fmt::Debug,
     hash::{Hash, Hasher},
-    iter,
+    iter, option,
 };
 
 use bevy_app::{App, Plugin, PostUpdate};
@@ -1291,9 +1291,19 @@ impl From<&Name> for AnimationTargetId {
     }
 }
 
-impl MapEntities for AnimationTarget {
-    fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
-        self.player = entity_mapper.map_entity(self.player);
+impl<'a> IntoIterator for &'a mut AnimationTarget {
+    type IntoIter = option::IntoIter<&'a mut Entity>;
+    type Item = <Self::IntoIter as Iterator>::Item;
+    fn into_iter(self) -> Self::IntoIter {
+        Some(&mut self.player).into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a AnimationTarget {
+    type IntoIter = option::IntoIter<Entity>;
+    type Item = <Self::IntoIter as Iterator>::Item;
+    fn into_iter(self) -> Self::IntoIter {
+        Some(self.player).into_iter()
     }
 }
 

crates/bevy_hierarchy/src/components/children.rs

@@ -28,14 +28,6 @@ use std::ops::Deref;
 #[cfg_attr(feature = "reflect", reflect(Component, MapEntities, Debug, FromWorld))]
 pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
-impl MapEntitiesMut for Children {
-    fn map_entities_mut<F: FnMut(&mut Entity)>(&mut self, mut f: F) {
-        for entity in &mut self.0 {
-            f(entity);
-        }
-    }
-}
-
 // TODO: We need to impl either FromWorld or Default so Children can be registered as Reflect.
 // This is because Reflect deserialize by creating an instance and apply a patch on top.
 // However Children should only ever be set with a real user-defined entities. Its worth looking
@@ -152,6 +144,17 @@ impl Deref for Children {
     }
 }
 
+impl<'a> IntoIterator for &'a mut Children {
+    type Item = <Self::IntoIter as Iterator>::Item;
+
+    type IntoIter = slice::IterMut<'a, Entity>;
+
+    #[inline(always)]
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter_mut()
+    }
+}
+
 impl<'a> IntoIterator for &'a Children {
     type Item = <Self::IntoIter as Iterator>::Item;
 
@@ -162,3 +165,15 @@ impl<'a> IntoIterator for &'a Children {
         self.0.iter().copied()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn assert_impls_map_entities_mut<M: MapEntitiesMut>() {}
+
+    #[test]
+    fn children_impls_map_entities_mut() {
+        assert_impls_map_entities_mut::<Children>();
+    }
+}

crates/bevy_render/src/mesh/mesh/skinning.rs

@@ -16,11 +16,21 @@ pub struct SkinnedMesh {
     pub joints: Vec<Entity>,
 }
 
-impl MapEntities for SkinnedMesh {
-    fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
-        for joint in &mut self.joints {
-            *joint = entity_mapper.map_entity(*joint);
-        }
+impl<'a> IntoIterator for &'a mut SkinnedMesh {
+    type IntoIter = std::slice::IterMut<'a, Entity>;
+    type Item = <Self::IntoIter as Iterator>::Item;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.joints.iter_mut()
+    }
+}
+
+impl<'a> IntoIterator for &'a SkinnedMesh {
+    type IntoIter = std::iter::Copied<std::slice::Iter<'a, Entity>>;
+    type Item = <Self::IntoIter as Iterator>::Item;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.joints.iter().copied()
     }
 }
 

crates/bevy_render/src/view/visibility/mod.rs

@@ -370,7 +370,7 @@ fn visibility_propagate_system(
             inherited_visibility.0 = is_visible;
 
             // Recursively update the visibility of each child.
-            for &child in children.into_iter().flatten() {
+            for child in children.into_iter().flatten() {
                 let _ =
                     propagate_recursive(is_visible, child, &mut visibility_query, &children_query);
             }
@@ -401,7 +401,7 @@ fn propagate_recursive(
         inherited_visibility.0 = is_visible;
 
         // Recursively update the visibility of each child.
-        for &child in children_query.get(entity).ok().into_iter().flatten() {
+        for child in children_query.get(entity).ok().into_iter().flatten() {
             let _ = propagate_recursive(is_visible, child, visibility_query, children_query);
         }
     }

crates/bevy_scene/src/dynamic_scene.rs

@@ -208,9 +208,11 @@ where
 
 #[cfg(test)]
 mod tests {
+    use std::option;
+
     use bevy_ecs::{
         component::Component,
-        entity::{Entity, EntityHashMap, EntityMapper, MapEntities},
+        entity::{Entity, EntityHashMap, EntityMapper, IterEntities, IterEntitiesMut, MapEntities},
         reflect::{
             AppTypeRegistry, ReflectComponent, ReflectMapEntities, ReflectMapEntitiesResource,
             ReflectResource,
@@ -231,10 +233,17 @@ mod tests {
         entity_b: Entity,
     }
 
-    impl MapEntities for TestResource {
-        fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
-            self.entity_a = entity_mapper.map_entity(self.entity_a);
-            self.entity_b = entity_mapper.map_entity(self.entity_b);
+    impl IterEntitiesMut for TestResource {
+        fn iter_entities_mut(&mut self) -> impl Iterator<Item = &mut Entity> {
+            Some(&mut self.entity_a)
+                .into_iter()
+                .chain(Some(&mut self.entity_b))
+        }
+    }
+
+    impl IterEntities for TestResource {
+        fn iter_entities(&self) -> impl Iterator<Item = Entity> {
+            Some(self.entity_a).into_iter().chain(Some(self.entity_b))
         }
     }
 
@@ -366,9 +375,19 @@ mod tests {
         #[reflect(Component, MapEntities)]
         struct B(pub Entity);
 
-        impl MapEntities for B {
-            fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
-                self.0 = entity_mapper.map_entity(self.0);
+        impl<'a> IntoIterator for &'a B {
+            type IntoIter = option::IntoIter<Entity>;
+            type Item = <Self::IntoIter as Iterator>::Item;
+            fn into_iter(self) -> Self::IntoIter {
+                Some(self.0).into_iter()
+            }
+        }
+
+        impl<'a> IntoIterator for &'a mut B {
+            type IntoIter = option::IntoIter<&'a mut Entity>;
+            type Item = <Self::IntoIter as Iterator>::Item;
+            fn into_iter(self) -> Self::IntoIter {
+                Some(&mut self.0).into_iter()
             }
         }
 

crates/bevy_scene/src/serde.rs

@@ -524,7 +524,7 @@ mod tests {
     use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
     use bincode::Options;
     use serde::{de::DeserializeSeed, Deserialize, Serialize};
-    use std::io::BufReader;
+    use std::{io::BufReader, option};
 
     #[derive(Component, Reflect, Default)]
     #[reflect(Component)]
@@ -588,9 +588,19 @@ mod tests {
     #[reflect(Component, MapEntities, PartialEq)]
     struct MyEntityRef(Entity);
 
-    impl MapEntities for MyEntityRef {
-        fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
-            self.0 = entity_mapper.map_entity(self.0);
+    impl<'a> IntoIterator for &'a mut MyEntityRef {
+        type IntoIter = option::IntoIter<&'a mut Entity>;
+        type Item = <Self::IntoIter as Iterator>::Item;
+        fn into_iter(self) -> Self::IntoIter {
+            Some(&mut self.0).into_iter()
+        }
+    }
+
+    impl<'a> IntoIterator for &'a MyEntityRef {
+        type IntoIter = option::IntoIter<Entity>;
+        type Item = <Self::IntoIter as Iterator>::Item;
+        fn into_iter(self) -> Self::IntoIter {
+            Some(self.0).into_iter()
         }
     }
 

crates/bevy_ui/src/accessibility.rs

@@ -22,7 +22,7 @@ use bevy_transform::prelude::GlobalTransform;
 fn calc_name(texts: &Query<&Text>, children: &Children) -> Option<Box<str>> {
     let mut name = None;
     for child in children {
-        if let Ok(text) = texts.get(*child) {
+        if let Ok(text) = texts.get(child) {
             let values = text
                 .sections
                 .iter()

crates/bevy_ui/src/layout/mod.rs

@@ -403,7 +403,7 @@ pub fn ui_layout_system(
             }
 
             if let Ok(children) = children_query.get(entity) {
-                for &child_uinode in children {
+                for child_uinode in children {
                     update_uinode_geometry_recursive(
                         commands,
                         child_uinode,

crates/bevy_ui/src/update.rs

@@ -93,7 +93,7 @@ fn update_clipping(
     };
 
     if let Ok(children) = children_query.get(entity) {
-        for &child in children {
+        for child in children {
             update_clipping(commands, children_query, node_query, child, children_clip);
         }
     }

crates/bevy_window/src/window.rs

@@ -1,4 +1,4 @@
-use std::num::NonZero;
+use std::{iter, num::NonZero, option};
 
 use bevy_ecs::{
     entity::{Entity, EntityMapper, MapEntities},
@@ -58,14 +58,27 @@ impl WindowRef {
     }
 }
 
-impl MapEntities for WindowRef {
-    fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
+impl<'a> IntoIterator for &'a WindowRef {
+    type Item = <Self::IntoIter as Iterator>::Item;
+    type IntoIter = option::IntoIter<Entity>;
+    fn into_iter(self) -> Self::IntoIter {
         match self {
-            Self::Entity(entity) => {
-                *entity = entity_mapper.map_entity(*entity);
-            }
-            Self::Primary => {}
-        };
+            WindowRef::Primary => None,
+            WindowRef::Entity(entity) => Some(*entity),
+        }
+        .into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a mut WindowRef {
+    type Item = <Self::IntoIter as Iterator>::Item;
+    type IntoIter = option::IntoIter<&'a mut Entity>;
+    fn into_iter(self) -> Self::IntoIter {
+        match self {
+            WindowRef::Primary => None,
+            WindowRef::Entity(entity) => Some(entity),
+        }
+        .into_iter()
     }
 }
 
@@ -1213,8 +1226,19 @@ pub struct ClosingWindow;
 
 #[cfg(test)]
 mod tests {
+    use bevy_ecs::entity::MapEntitiesMut;
+
     use super::*;
 
+    // Compile-time assertion that a type implementes MapEntitiesMut
+    fn impl_map_entities_mut<M: MapEntitiesMut>() {}
+
+    // Ensure that WidowRef implements MapEntitiesMut
+    #[allow(dead_code)]
+    fn window_impls_map_entities_mut() {
+        impl_map_entities_mut::<WindowRef>();
+    }
+
     // Checks that `Window::physical_cursor_position` returns the cursor position if it is within
     // the bounds of the window.
     #[test]