Add World::iter_resources() and World::iter_resources_mut() methods

[coreh]

Objective

• I would like to be able to easily iterate over all the resources in a given World;
• As I'm doing so, I'd like be able to query ComponentInfo (e.g. for reflection) and also read (and optionally mutate) the resources directly.

Solution

• Introduce World::iter_resources() and World::iter_resources_mut() methods;
• These methods return impl Iterator<Item = (&ComponentInfo, Ptr<'_>)> and impl Iterator<Item = (&ComponentInfo, MutUntyped<'_>)>, respectively.

Note: My original implementation in the remote protocol branch also added methods for !Send resources, but as suggested by WrongShoe on discord, I'm holding off on that since #9122 is likely to land soon.

Note 2: Related to #4955 (But much smaller/more constrained, this requires World access and unsafe)

---

Changelog

• Added World::iter_resources() and World::iter_resources_mut() methods for iterating all resources dynamically at run time;

[alice-i-cecile]

@james-j-obrien, can I get your review / help with this? It very much feels like a sibling of the dynamic query work.

[coreh]

@james-j-obrien Thanks! That makes me more confident with what I was doing. Updated the safety comments with the explanations.

Edit: Added you as a co-author, if that's okay, since I really wouldn't have been able to verify this on my own (or even be able to fully reason about the safety of this without your explanations.)

[doonv]

This code looks good, but I have a question:

It was already possible possible to get all resources from a World in Bevy, just more complicated:

1. Get the AppTypeRegistry resource
2. Get a RwLockReadGuard<TypeRegistry> from AppTypeRegistry::read
3. Filter the registrations by if they are a resource in the World

 registry_lock
            .iter()
            .filter(|registration| {
                world
                    .components()
                    .get_resource_id(registration.type_id())
                    .is_some()
            })

4. You now have an iterator of &TypeRegistrations, which you can use to get references to the resources.

Aside from being simpler, how does this differ from the above solution?

[coreh]

Hmm honestly I wasn't aware you could do that, TIL.

If I understand it correctly, besides being more easily discoverable and somewhat shorter to use, the API in this PR has the benefits of:

• Not requiring the filtering (so it should be faster, depending on how many non-resource components are in the world. Not sure how relevant that is in practice for real scenarios)
• It allows you to easily mutate the resources as you iterate them, which would be cumbersome otherwise, since the filter closure needs a read reference to the world

[james7132]

This change currently assumes that Resources::iter only returns present resources, when in practice it returns all resources ever initialized within the World, some of which may have been removed. The implementation here can be significantly simpler and not involve panics.

[james7132]

These need a test case to ensure that iteration doesn't panic if you remove a resource. Also for miri.

[james7132]

These need a test case to ensure that iteration doesn't panic if you remove a resource. Also for miri.

[james7132]

Suggested change

	self.storages.resources.iter().map(|(component_id, data)| {
	let component_info = self.components.get_info(component_id).unwrap_or_else(|| {
	panic!("ComponentInfo should exist for all resources in the world, but it does not for {:?}", component_id);
	});
	let ptr = data.get_data().unwrap_or_else(|| {
	panic!(
	"When iterating all resources, resource of type {} was supposed to exist, but did not.",
	component_info.name()
	)
	});
	(component_info, ptr)
	self.storages.resources.iter().filter_map(|(component_id, data)| {
	Some((component_id, data.get_ptr()?)

[james7132]

Suggested change

	self.storages.resources.iter().map(|(component_id, data)| {
	let component_info = self.components.get_info(component_id).unwrap_or_else(|| {
	panic!("ComponentInfo should exist for all resources in the world, but it does not for {:?}", component_id);
	});
	let (ptr, ticks) = data.get_with_ticks().unwrap_or_else(|| {
	panic!(
	"When iterating all resources, resource of type {} was supposed to exist, but did not.",
	component_info.name()
	)
	});
	// SAFETY:
	// - We have exclusive access to the world, so no other code can be aliasing the `TickCells`
	// - We only hold one `TicksMut` at a time, and we let go of it before getting the next one
	let ticks = unsafe {
	TicksMut::from_tick_cells(ticks, self.last_change_tick(), self.read_change_tick())
	};
	let mut_untyped = MutUntyped {
	// SAFETY:
	// - We have exclusive access to the world, so no other code can be aliasing the `Ptr`
	// - We iterate one resource at a time, and we let go of each `PtrMut` before getting the next one
	value: unsafe { ptr.assert_unique() },
	ticks,
	};
	(component_info, mut_untyped)
	self.storages.resources.iter().filter_map(|(component_id, data)| {
	let (ptr, ticks) = data.get_with_ticks()?;
	// SAFETY:
	// - We have exclusive access to the world, so no other code can be aliasing the `TickCells`
	// - We only hold one `TicksMut` at a time, and we let go of it before getting the next one
	let ticks = unsafe {
	TicksMut::from_tick_cells(ticks, self.last_change_tick(), self.read_change_tick())
	};
	let mut_untyped = MutUntyped {
	// SAFETY:
	// - We have exclusive access to the world, so no other code can be aliasing the `Ptr`
	// - We iterate one resource at a time, and we let go of each `PtrMut` before getting the next one
	value: unsafe { ptr.assert_unique() },
	ticks,
	};
	Some((component_info, mut_untyped))