hashset iter

Author: aggyomfg

assets/tests/iter/hashset.lua

@@ -0,0 +1,19 @@
+local res_type = world.get_type_by_name("TestResourceWithVariousFields")
+local res = world.get_resource(res_type)
+
+local set = res.string_set
+
+local iterator = set:iter()
+local count = 0
+local found_values = {}
+
+local result = iterator()
+while result ~= nil do
+    count = count + 1
+    found_values[result] = true
+    result = iterator()
+end
+
+assert(count == 2, "Expected 2 entries, got " .. count)
+assert(found_values["apple"] == true, "Expected to find 'apple'")
+assert(found_values["banana"] == true, "Expected to find 'banana'")

assets/tests/iter/hashset.rhai

@@ -0,0 +1,29 @@
+let res_type = world.get_type_by_name.call("TestResourceWithVariousFields");
+let res = world.get_resource.call(res_type);
+
+let set = res.string_set;
+
+let iterator = set.iter();
+let count = 0;
+let found_values = #{};
+
+loop {
+    let result = iterator.next();
+    
+    if result == () {
+        break;
+    }
+    
+    count += 1;
+    found_values[result] = true;
+}
+
+if count != 2 {
+    throw `Expected 2 entries, got ${count}`;
+}
+if found_values["apple"] != true {
+    throw "Expected to find 'apple'";
+}
+if found_values["banana"] != true {
+    throw "Expected to find 'banana'";
+}

assets/tests/iter/hashset_pairs.lua

@@ -0,0 +1,22 @@
+local res_type = world.get_type_by_name("TestResourceWithVariousFields")
+local res = world.get_resource(res_type)
+
+local set = res.string_set
+
+local count = 0
+local found_values = {}
+
+for value in pairs(set) do
+    count = count + 1
+    found_values[value] = true
+end
+
+if count ~= 2 then
+    error(string.format("Expected 2 entries, got %d", count))
+end
+if found_values["apple"] ~= true then
+    error("Expected to find 'apple'")
+end
+if found_values["banana"] ~= true then
+    error("Expected to find 'banana'")
+end

crates/bevy_mod_scripting_bindings/src/reference.rs

@@ -146,6 +146,12 @@ impl ReflectReference {
         }
     }
 
+    /// Creates a new iterator for Sets specifically.
+    /// Unlike `into_iter_infinite`, this iterator is finite and will return None when exhausted.
+    pub fn into_set_iter(self, world: WorldGuard) -> Result<ReflectSetRefIter, InteropError> {
+        ReflectSetRefIter::new(self, world)
+    }
+
     /// If this is a reference to something with a length accessible via reflection, returns that length.
     pub fn len(&self, world: WorldGuard) -> Result<Option<usize>, InteropError> {
         self.with_reflect(world, |r| match r.reflect_ref() {
@@ -1197,6 +1203,65 @@ impl ReflectMapRefIter {
     }
 }
 
+/// Iterator specifically for Sets that doesn't use the path system.
+/// This collects all set values in a Vec to enable O(1) iteration, but with memory overhead.
+pub struct ReflectSetRefIter {
+    values: Vec<ReflectReference>,
+    index: usize,
+}
+
+#[profiling::all_functions]
+impl ReflectSetRefIter {
+    /// Creates a new set iterator by collecting all values from the set in a Vec.
+    pub fn new(base: ReflectReference, world: WorldGuard) -> Result<Self, InteropError> {
+        let values = base.with_reflect(world.clone(), |reflect| match reflect.reflect_ref() {
+            ReflectRef::Set(set) => {
+                let allocator = world.allocator();
+                let mut allocator_guard = allocator.write();
+                
+                let mut collected_values = Vec::with_capacity(set.len());
+                
+                for value in set.iter() {
+                    let owned_value = <dyn PartialReflect>::from_reflect(value, world.clone())?;
+                    let value_ref = ReflectReference::new_allocated_boxed(
+                        owned_value,
+                        &mut *allocator_guard,
+                    );
+                    collected_values.push(value_ref);
+                }
+                
+                drop(allocator_guard);
+                Ok(collected_values)
+            }
+            _ => Err(InteropError::unsupported_operation(
+                reflect.get_represented_type_info().map(|ti| ti.type_id()),
+                None,
+                "set iteration on non-set type".to_owned(),
+            )),
+        })??;
+        
+        Ok(Self {
+            values,
+            index: 0,
+        })
+    }
+    
+    /// Returns the next set entry.
+    /// Returns Ok(None) when there are no more entries.
+    pub fn next_cloned(
+        &mut self,
+        _world: WorldGuard,
+    ) -> Result<Option<ReflectReference>, InteropError> {
+        if self.index < self.values.len() {
+            let value = self.values[self.index].clone();
+            self.index += 1;
+            Ok(Some(value))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
 #[profiling::all_functions]
 impl Iterator for ReflectRefIter {
     type Item = Result<ReflectReference, InteropError>;

crates/bevy_mod_scripting_functions/src/core.rs

@@ -7,7 +7,6 @@ use std::ops::Deref;
 use bevy_app::App;
 use bevy_asset::{AssetServer, Handle};
 use bevy_ecs::{entity::Entity, prelude::AppTypeRegistry, schedule::Schedules, world::World};
-use bevy_reflect::ReflectRef;
 use bevy_mod_scripting_bindings::{
     DynamicScriptFunctionMut, FunctionInfo, GlobalNamespace, InteropError, PartialReflectExt,
     ReflectReference, ScriptComponentRegistration, ScriptQueryBuilder, ScriptQueryResult,
@@ -729,6 +728,10 @@ impl ReflectReference {
     /// Iterates over the reference, if the reference is an appropriate container type.
     /// Uses `from_reflect` to create fully reflected clones that can be used with all operations.
     ///
+    /// For Maps, returns an iterator function that returns [key, value] pairs.
+    /// For Sets, returns an iterator function that returns individual values.
+    /// For other containers (Lists, Arrays), returns an iterator function that returns individual elements.
+    ///
     /// Returns an "next" iterator function that returns fully reflected values (Box<dyn Reflect>).
     ///
     /// The iterator function should be called until it returns `nil` to signal the end of the iteration.
@@ -745,10 +748,8 @@ impl ReflectReference {
         profiling::function_scope!("iter");
         let world = ctxt.world()?;
         let mut len = reference.len(world.clone())?.unwrap_or_default();
-        // Check if this is a Map type
-        let is_map = reference.with_reflect(world.clone(), |r| {
-            matches!(r.reflect_ref(), ReflectRef::Map(_))
-        })?;
+        let is_map = reference.is_map(world.clone())?;
+        let is_set = reference.is_set(world.clone())?;
 
         if is_map {
             // Use special map iterator that clones values
@@ -770,6 +771,21 @@ impl ReflectReference {
                 }
             };
             Ok(iter_function.into_dynamic_script_function_mut())
+        } else if is_set {
+            // Use special set iterator that clones values upfront for efficient iteration
+            let mut set_iter = reference.into_set_iter(world.clone())?;
+            let iter_function = move || {
+                if len == 0 {
+                    return Ok(ScriptValue::Unit);
+                }
+                len -= 1;
+                let world = ThreadWorldContainer.try_get_world()?;
+                match set_iter.next_cloned(world.clone())? {
+                    Some(value_ref) => ReflectReference::into_script_ref(value_ref, world),
+                    None => Ok(ScriptValue::Unit),
+                }
+            };
+            Ok(iter_function.into_dynamic_script_function_mut())
         } else {
             // Use cloning iterator for lists/arrays
             let mut infinite_iter = reference.into_iter_infinite();
@@ -780,10 +796,7 @@ impl ReflectReference {
                 len -= 1;
                 let world = ThreadWorldContainer.try_get_world()?;
                 match infinite_iter.next_cloned(world.clone())? {
-                    Some(value_ref) => {
-                        // Convert the cloned value to a script value
-                        ReflectReference::into_script_ref(value_ref, world)
-                    }
+                    Some(value_ref) => ReflectReference::into_script_ref(value_ref, world),
                     None => Ok(ScriptValue::Unit),
                 }
             };