fix map apply, remove get_at/_mut & add retain to Map

Author: Azorlogh

crates/bevy_reflect/src/impls/alloc/collections/btree/map.rs

@@ -2,7 +2,7 @@ use crate::{
     error::ReflectCloneError,
     generics::{Generics, TypeParamInfo},
     kind::{ReflectKind, ReflectMut, ReflectOwned, ReflectRef},
-    map::{map_apply, map_partial_eq, map_try_apply, Map, MapInfo, MapIter},
+    map::{map_apply, map_partial_eq, map_try_apply, Map, MapInfo},
     prelude::*,
     reflect::{impl_full_reflect, ApplyError},
     type_info::{MaybeTyped, TypeInfo, Typed},
@@ -31,27 +31,15 @@ where
             .map(|value| value as &mut dyn PartialReflect)
     }
 
-    fn get_at(&self, index: usize) -> Option<(&dyn PartialReflect, &dyn PartialReflect)> {
-        self.iter()
-            .nth(index)
-            .map(|(key, value)| (key as &dyn PartialReflect, value as &dyn PartialReflect))
-    }
-
-    fn get_at_mut(
-        &mut self,
-        index: usize,
-    ) -> Option<(&dyn PartialReflect, &mut dyn PartialReflect)> {
-        self.iter_mut()
-            .nth(index)
-            .map(|(key, value)| (key as &dyn PartialReflect, value as &mut dyn PartialReflect))
-    }
-
     fn len(&self) -> usize {
         Self::len(self)
     }
 
-    fn iter(&self) -> MapIter {
-        MapIter::new(self)
+    fn iter(&self) -> Box<dyn Iterator<Item = (&dyn PartialReflect, &dyn PartialReflect)> + '_> {
+        Box::new(
+            self.iter()
+                .map(|(k, v)| (k as &dyn PartialReflect, v as &dyn PartialReflect)),
+        )
     }
 
     fn drain(&mut self) -> Vec<(Box<dyn PartialReflect>, Box<dyn PartialReflect>)> {
@@ -68,6 +56,10 @@ where
         result
     }
 
+    fn retain(&mut self, f: &mut dyn FnMut(&dyn PartialReflect, &mut dyn PartialReflect) -> bool) {
+        self.retain(move |k, v| f(k, v));
+    }
+
     fn insert_boxed(
         &mut self,
         key: Box<dyn PartialReflect>,

crates/bevy_reflect/src/impls/macros/map.rs

@@ -19,27 +19,12 @@ macro_rules! impl_reflect_for_hashmap {
                         .map(|value| value as &mut dyn $crate::reflect::PartialReflect)
                 }
 
-                fn get_at(&self, index: usize) -> Option<(&dyn $crate::reflect::PartialReflect, &dyn $crate::reflect::PartialReflect)> {
-                    self.iter()
-                        .nth(index)
-                        .map(|(key, value)| (key as &dyn $crate::reflect::PartialReflect, value as &dyn $crate::reflect::PartialReflect))
-                }
-
-                fn get_at_mut(
-                    &mut self,
-                    index: usize,
-                ) -> Option<(&dyn $crate::reflect::PartialReflect, &mut dyn $crate::reflect::PartialReflect)> {
-                    self.iter_mut().nth(index).map(|(key, value)| {
-                        (key as &dyn $crate::reflect::PartialReflect, value as &mut dyn $crate::reflect::PartialReflect)
-                    })
-                }
-
                 fn len(&self) -> usize {
                     Self::len(self)
                 }
 
-                fn iter(&self) -> $crate::map::MapIter {
-                    $crate::map::MapIter::new(self)
+                fn iter(&self) -> bevy_platform::prelude::Box<dyn Iterator<Item = (&dyn $crate::reflect::PartialReflect, &dyn $crate::reflect::PartialReflect)> + '_> {
+                    bevy_platform::prelude::Box::new(self.iter().map(|(k, v)| (k as &dyn $crate::reflect::PartialReflect, v as &dyn $crate::reflect::PartialReflect)))
                 }
 
                 fn drain(&mut self) -> bevy_platform::prelude::Vec<(bevy_platform::prelude::Box<dyn $crate::reflect::PartialReflect>, bevy_platform::prelude::Box<dyn $crate::reflect::PartialReflect>)> {
@@ -53,6 +38,10 @@ macro_rules! impl_reflect_for_hashmap {
                         .collect()
                 }
 
+                fn retain(&mut self, f: &mut dyn FnMut(&dyn $crate::reflect::PartialReflect, &mut dyn $crate::reflect::PartialReflect) -> bool) {
+                    self.retain(move |key, value| f(key, value));
+                }
+
                 fn to_dynamic_map(&self) -> $crate::map::DynamicMap {
                     let mut dynamic_map = $crate::map::DynamicMap::default();
                     dynamic_map.set_represented_type($crate::reflect::PartialReflect::get_represented_type_info(self));

crates/bevy_reflect/src/impls/macros/set.rs

@@ -28,6 +28,10 @@ macro_rules! impl_reflect_for_hashset {
                         .collect()
                 }
 
+                fn retain(&mut self, f: &mut dyn FnMut(&dyn $crate::reflect::PartialReflect) -> bool) {
+                    self.retain(move |value| f(value));
+                }
+
                 fn insert_boxed(&mut self, value: bevy_platform::prelude::Box<dyn $crate::reflect::PartialReflect>) -> bool {
                     let value = V::take_from_reflect(value).unwrap_or_else(|value| {
                         panic!(