add IterEntities traits and rebase MapEntities on them

Author: jrobsonchase

crates/bevy_ecs/src/entity/map_entities.rs

@@ -47,20 +47,46 @@ pub trait MapEntitiesMut: MapEntities {
 
 impl<T> MapEntities for T
 where
-    for<'a> &'a T: IntoIterator<Item = Entity>,
+    T: IterEntities,
 {
     fn map_entities<F: FnMut(Entity)>(&self, f: F) {
-        self.into_iter().for_each(f);
+        self.iter_entities().for_each(f)
     }
 }
 
 impl<T> MapEntitiesMut for T
 where
-    for<'a> &'a mut T: IntoIterator<Item = &'a mut Entity>,
-    T: MapEntities,
+    T: MapEntities + IterEntitiesMut,
 {
     fn map_entities_mut<F: FnMut(&mut Entity)>(&mut self, f: F) {
-        self.into_iter().for_each(f);
+        self.iter_entities_mut().for_each(f)
+    }
+}
+
+pub trait IterEntities {
+    fn iter_entities(&self) -> impl Iterator<Item = Entity>;
+}
+
+impl<T> IterEntities for T
+where
+    for<'a> &'a T: IntoIterator<Item = Entity>,
+{
+    fn iter_entities(&self) -> impl Iterator<Item = Entity> {
+        self.into_iter()
+    }
+}
+
+pub trait IterEntitiesMut: IterEntities {
+    fn iter_entities_mut(&mut self) -> impl Iterator<Item = &mut Entity>;
+}
+
+impl<T> IterEntitiesMut for T
+where
+    for<'a> &'a mut T: IntoIterator<Item = &'a mut Entity>,
+    T: IterEntities,
+{
+    fn iter_entities_mut(&mut self) -> impl Iterator<Item = &mut Entity> {
+        self.into_iter()
     }
 }
 

crates/bevy_hierarchy/src/components/children.rs

@@ -2,7 +2,7 @@
 use bevy_ecs::reflect::{ReflectComponent, ReflectFromWorld, ReflectMapEntities};
 use bevy_ecs::{
     component::Component,
-    entity::{Entity, EntityMapper, MapEntities},
+    entity::{Entity, MapEntitiesMut},
     prelude::FromWorld,
     world::World,
 };
@@ -28,10 +28,10 @@ use std::ops::Deref;
 #[cfg_attr(feature = "reflect", reflect(Component, MapEntities, Debug, FromWorld))]
 pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
-impl MapEntities for Children {
-    fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
+impl MapEntitiesMut for Children {
+    fn map_entities_mut<F: FnMut(&mut Entity)>(&mut self, mut f: F) {
         for entity in &mut self.0 {
-            *entity = entity_mapper.map_entity(*entity);
+            f(entity);
         }
     }
 }
@@ -155,10 +155,10 @@ impl Deref for Children {
 impl<'a> IntoIterator for &'a Children {
     type Item = <Self::IntoIter as Iterator>::Item;
 
-    type IntoIter = slice::Iter<'a, Entity>;
+    type IntoIter = std::iter::Copied<slice::Iter<'a, Entity>>;
 
     #[inline(always)]
     fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
+        self.0.iter().copied()
     }
 }

crates/bevy_hierarchy/src/components/parent.rs

@@ -2,11 +2,11 @@
 use bevy_ecs::reflect::{ReflectComponent, ReflectFromWorld, ReflectMapEntities};
 use bevy_ecs::{
     component::Component,
-    entity::{Entity, EntityMapper, MapEntities},
+    entity::Entity,
     traversal::Traversal,
     world::{FromWorld, World},
 };
-use std::ops::Deref;
+use std::{ops::Deref, option};
 
 /// Holds a reference to the parent entity of this entity.
 /// This component should only be present on entities that actually have a parent entity.
@@ -59,9 +59,21 @@ impl FromWorld for Parent {
     }
 }
 
-impl MapEntities for Parent {
-    fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M) {
-        self.0 = entity_mapper.map_entity(self.0);
+impl<'a> IntoIterator for &'a Parent {
+    type Item = Entity;
+    type IntoIter = option::IntoIter<Entity>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Some(self.0).into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a mut Parent {
+    type Item = &'a mut Entity;
+    type IntoIter = option::IntoIter<&'a mut Entity>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Some(&mut self.0).into_iter()
     }
 }
 

crates/bevy_hierarchy/src/query_extension.rs

@@ -92,12 +92,7 @@ where
     pub fn new(children_query: &'w Query<'w, 's, D, F>, entity: Entity) -> Self {
         DescendantIter {
             children_query,
-            vecdeque: children_query
-                .get(entity)
-                .into_iter()
-                .flatten()
-                .copied()
-                .collect(),
+            vecdeque: children_query.get(entity).into_iter().flatten().collect(),
         }
     }
 }

crates/bevy_ui/src/layout/ui_surface.rs

@@ -117,7 +117,7 @@ impl UiSurface {
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
-            if let Some(taffy_node) = self.entity_to_taffy.get(child) {
+            if let Some(taffy_node) = self.entity_to_taffy.get(&child) {
                 taffy_children.push(*taffy_node);
             } else {
                 warn!(

crates/bevy_ui/src/stack.rs

@@ -108,7 +108,7 @@ fn insert_context_hierarchy(
                 cache,
                 zindex_query,
                 children_query,
-                *entity,
+                entity,
                 global_context,
                 Some(&mut new_context),
                 total_entry_count,

crates/bevy_ui/src/update.rs

@@ -153,7 +153,7 @@ fn update_children_target_camera(
         return;
     };
 
-    for &child in children {
+    for child in children {
         // Skip if the child has already been updated or update is not needed
         if updated_entities.contains(&child)
             || camera_to_set == node_query.get(child).ok().flatten()

examples/ecs/hierarchy.rs

@@ -72,7 +72,7 @@ fn rotate(
         // To iterate through the entities children, just treat the Children component as a Vec
         // Alternatively, you could query entities that have a Parent component
         for child in children {
-            if let Ok(mut transform) = transform_query.get_mut(*child) {
+            if let Ok(mut transform) = transform_query.get_mut(child) {
                 transform.rotate_z(PI * time.delta_seconds());
             }
         }

examples/ui/display_and_visibility.rs

@@ -442,7 +442,7 @@ fn buttons_handler<T>(
     for (target, interaction, children) in visibility_button_query.iter_mut() {
         if matches!(interaction, Interaction::Pressed) {
             let mut target_value = left_panel_query.get_mut(target.id).unwrap();
-            for &child in children {
+            for child in children {
                 if let Ok(mut text) = text_query.get_mut(child) {
                     text.sections[0].value = target.update_target(target_value.as_mut());
                     text.sections[0].style.color = if text.sections[0].value.contains("None")
@@ -466,7 +466,7 @@ fn text_hover(
         match interaction {
             Interaction::Hovered => {
                 *color = Color::BLACK.with_alpha(0.6).into();
-                for &child in children {
+                for child in children {
                     if let Ok(mut text) = text_query.get_mut(child) {
                         // Bypass change detection to avoid recomputation of the text when only changing the color
                         text.bypass_change_detection().sections[0].style.color = YELLOW.into();
@@ -475,7 +475,7 @@ fn text_hover(
             }
             _ => {
                 *color = Color::BLACK.with_alpha(0.5).into();
-                for &child in children {
+                for child in children {
                     if let Ok(mut text) = text_query.get_mut(child) {
                         text.bypass_change_detection().sections[0].style.color =
                             if text.sections[0].value.contains("None")

examples/ui/size_constraints.rs

@@ -324,9 +324,9 @@ fn update_buttons(
             }
             Interaction::Hovered => {
                 if let Ok(children) = children_query.get(button_id) {
-                    for &child in children {
+                    for child in children {
                         if let Ok(grand_children) = children_query.get(child) {
-                            for &grandchild in grand_children {
+                            for grandchild in grand_children {
                                 if let Ok(mut text) = text_query.get_mut(grandchild) {
                                     if text.sections[0].style.color != ACTIVE_TEXT_COLOR {
                                         text.sections[0].style.color = HOVERED_TEXT_COLOR;
@@ -339,9 +339,9 @@ fn update_buttons(
             }
             Interaction::None => {
                 if let Ok(children) = children_query.get(button_id) {
-                    for &child in children {
+                    for child in children {
                         if let Ok(grand_children) = children_query.get(child) {
-                            for &grandchild in grand_children {
+                            for grandchild in grand_children {
                                 if let Ok(mut text) = text_query.get_mut(grandchild) {
                                     if text.sections[0].style.color != ACTIVE_TEXT_COLOR {
                                         text.sections[0].style.color = UNHOVERED_TEXT_COLOR;
@@ -383,9 +383,9 @@ fn update_radio_buttons_colors(
                 };
 
                 border_query.get_mut(id).unwrap().0 = border_color;
-                for &child in children_query.get(id).into_iter().flatten() {
+                for child in children_query.get(id).into_iter().flatten() {
                     color_query.get_mut(child).unwrap().0 = inner_color;
-                    for &grandchild in children_query.get(child).into_iter().flatten() {
+                    for grandchild in children_query.get(child).into_iter().flatten() {
                         if let Ok(mut text) = text_query.get_mut(grandchild) {
                             text.sections[0].style.color = text_color;
                         }