forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename get_multiple APIs to get_many (#4384)

Browse Source 
# Objective

-  std's new APIs do the same thing as `Query::get_multiple_mut`, but are called `get_many`: https://github.com/rust-lang/rust/pull/83608

## Solution

- Find and replace `get_multiple` with `get_many`
This commit is contained in:
Alice Cecile 2022-03-31 20:59:26 +00:00
parent 48ac955afd
commit b33dae31ec
6 changed files with 41 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
crates/bevy_ecs/src/query/state.rs
View File

@ -158,7 +158,7 @@ where
/// In case of a nonexisting entity or mismatched component, a [`QueryEntityError`] is
/// returned instead.
///
/// Note that the unlike [`QueryState::get_multiple_mut`], the entities passed in do not need to be unique.
/// Note that the unlike [`QueryState::get_many_mut`], the entities passed in do not need to be unique.
///
/// # Examples
///
@ -177,16 +177,16 @@ where
///
/// let mut query_state = world.query::<&A>();
///
/// let component_values = query_state.get_multiple(&world, entities).unwrap();
/// let component_values = query_state.get_many(&world, entities).unwrap();
///
/// assert_eq!(component_values, [&A(0), &A(1), &A(2)]);
///
/// let wrong_entity = Entity::from_raw(365);
///
/// assert_eq!(query_state.get_multiple(&world, [wrong_entity]), Err(QueryEntityError::NoSuchEntity(wrong_entity)));
/// assert_eq!(query_state.get_many(&world, [wrong_entity]), Err(QueryEntityError::NoSuchEntity(wrong_entity)));
/// ```
#[inline]
pub fn get_multiple<'w, 's, const N: usize>(
pub fn get_many<'w, 's, const N: usize>(
&'s mut self,
world: &'w World,
entities: [Entity; N],
@ -195,7 +195,7 @@ where
// SAFE: update_archetypes validates the `World` matches
unsafe {
self.get_multiple_read_only_manual(
self.get_many_read_only_manual(
world,
entities,
world.last_change_tick(),
@ -244,25 +244,25 @@ where
///
/// let mut query_state = world.query::<&mut A>();
///
/// let mut mutable_component_values = query_state.get_multiple_mut(&mut world, entities).unwrap();
/// let mut mutable_component_values = query_state.get_many_mut(&mut world, entities).unwrap();
///
/// for mut a in mutable_component_values.iter_mut(){
/// a.0 += 5;
/// }
///
/// let component_values = query_state.get_multiple(&world, entities).unwrap();
/// let component_values = query_state.get_many(&world, entities).unwrap();
///
/// assert_eq!(component_values, [&A(5), &A(6), &A(7)]);
///
/// let wrong_entity = Entity::from_raw(57);
/// let invalid_entity = world.spawn().id();
///
/// assert_eq!(query_state.get_multiple_mut(&mut world, [wrong_entity]).unwrap_err(), QueryEntityError::NoSuchEntity(wrong_entity));
/// assert_eq!(query_state.get_multiple_mut(&mut world, [invalid_entity]).unwrap_err(), QueryEntityError::QueryDoesNotMatch(invalid_entity));
/// assert_eq!(query_state.get_multiple_mut(&mut world, [entities[0], entities[0]]).unwrap_err(), QueryEntityError::AliasedMutability(entities[0]));
/// assert_eq!(query_state.get_many_mut(&mut world, [wrong_entity]).unwrap_err(), QueryEntityError::NoSuchEntity(wrong_entity));
/// assert_eq!(query_state.get_many_mut(&mut world, [invalid_entity]).unwrap_err(), QueryEntityError::QueryDoesNotMatch(invalid_entity));
/// assert_eq!(query_state.get_many_mut(&mut world, [entities[0], entities[0]]).unwrap_err(), QueryEntityError::AliasedMutability(entities[0]));
/// ```
#[inline]
pub fn get_multiple_mut<'w, 's, const N: usize>(
pub fn get_many_mut<'w, 's, const N: usize>(
&'s mut self,
world: &'w mut World,
entities: [Entity; N],
@ -272,7 +272,7 @@ where
// SAFE: method requires exclusive world access
// and world has been validated via update_archetypes
unsafe {
self.get_multiple_unchecked_manual(
self.get_many_unchecked_manual(
world,
entities,
world.last_change_tick(),
@ -368,7 +368,7 @@ where
///
/// This must be called on the same `World` that the `Query` was generated from:
/// use `QueryState::validate_world` to verify this.
pub(crate) unsafe fn get_multiple_read_only_manual<'s, 'w, const N: usize>(
pub(crate) unsafe fn get_many_read_only_manual<'s, 'w, const N: usize>(
&'s self,
world: &'w World,
entities: [Entity; N],
@ -409,7 +409,7 @@ where
///
/// This must be called on the same `World` that the `Query` was generated from:
/// use `QueryState::validate_world` to verify this.
pub(crate) unsafe fn get_multiple_unchecked_manual<'s, 'w, const N: usize>(
pub(crate) unsafe fn get_many_unchecked_manual<'s, 'w, const N: usize>(
&'s self,
world: &'w World,
entities: [Entity; N],
@ -941,7 +941,7 @@ mod tests {
use crate::{prelude::*, query::QueryEntityError};
#[test]
fn get_multiple_unchecked_manual_uniqueness() {
fn get_many_unchecked_manual_uniqueness() {
let mut world = World::new();
let entities: Vec<Entity> = (0..10).map(|_| world.spawn().id()).collect();
@ -952,12 +952,12 @@ mod tests {
let last_change_tick = world.last_change_tick();
let change_tick = world.read_change_tick();
// It's best to test get_multiple_unchecked_manual directly,
// It's best to test get_many_unchecked_manual directly,
// as it is shared and unsafe
// We don't care about aliased mutabilty for the read-only equivalent
assert!(unsafe {
query_state
.get_multiple_unchecked_manual::<10>(
.get_many_unchecked_manual::<10>(
&world,
entities.clone().try_into().unwrap(),
last_change_tick,
@ -969,7 +969,7 @@ mod tests {
assert_eq!(
unsafe {
query_state
.get_multiple_unchecked_manual(
.get_many_unchecked_manual(
&world,
[entities[0], entities[0]],
last_change_tick,
@ -983,7 +983,7 @@ mod tests {
assert_eq!(
unsafe {
query_state
.get_multiple_unchecked_manual(
.get_many_unchecked_manual(
&world,
[entities[0], entities[1], entities[0]],
last_change_tick,
@ -997,7 +997,7 @@ mod tests {
assert_eq!(
unsafe {
query_state
.get_multiple_unchecked_manual(
.get_many_unchecked_manual(
&world,
[entities[9], entities[9]],
last_change_tick,
@ -1021,21 +1021,21 @@ mod tests {
#[test]
#[should_panic]
fn right_world_get_multiple() {
fn right_world_get_many() {
let mut world_1 = World::new();
let world_2 = World::new();
let mut query_state = world_1.query::<Entity>();
let _panics = query_state.get_multiple(&world_2, []);
let _panics = query_state.get_many(&world_2, []);
}
#[test]
#[should_panic]
fn right_world_get_multiple_mut() {
fn right_world_get_many_mut() {
let mut world_1 = World::new();
let mut world_2 = World::new();
let mut query_state = world_1.query::<Entity>();
let _panics = query_state.get_multiple_mut(&mut world_2, []);
let _panics = query_state.get_many_mut(&mut world_2, []);
}
}

18
crates/bevy_ecs/src/system/query.rs
View File

@ -623,17 +623,17 @@ where
/// In case of a nonexisting entity or mismatched component, a [`QueryEntityError`] is
/// returned instead.
///
/// Note that the unlike [`Query::get_multiple_mut`], the entities passed in do not need to be unique.
/// Note that the unlike [`Query::get_many_mut`], the entities passed in do not need to be unique.
///
/// See [`Query::multiple`] for the infallible equivalent.
#[inline]
pub fn get_multiple<const N: usize>(
pub fn get_many<const N: usize>(
&self,
entities: [Entity; N],
) -> Result<[<Q::ReadOnlyFetch as Fetch<'_, 's>>::Item; N], QueryEntityError> {
// SAFE: it is the scheduler's responsibility to ensure that `Query` is never handed out on the wrong `World`.
unsafe {
self.state.get_multiple_read_only_manual(
self.state.get_many_read_only_manual(
self.world,
entities,
self.last_change_tick,
@ -644,7 +644,7 @@ where
/// Returns the read-only query items for the provided array of [`Entity`]
///
/// See [`Query::get_multiple`] for the [`Result`]-returning equivalent.
/// See [`Query::get_many`] for the [`Result`]-returning equivalent.
///
/// # Examples
/// ```rust, no_run
@ -682,7 +682,7 @@ where
&self,
entities: [Entity; N],
) -> [<Q::ReadOnlyFetch as Fetch<'_, 's>>::Item; N] {
self.get_multiple(entities).unwrap()
self.get_many(entities).unwrap()
}
/// Returns the query result for the given [`Entity`].
@ -733,13 +733,13 @@ where
///
/// See [`Query::multiple_mut`] for the infallible equivalent.
#[inline]
pub fn get_multiple_mut<const N: usize>(
pub fn get_many_mut<const N: usize>(
&mut self,
entities: [Entity; N],
) -> Result<[<Q::Fetch as Fetch<'_, 's>>::Item; N], QueryEntityError> {
// SAFE: scheduler ensures safe Query world access
unsafe {
self.state.get_multiple_unchecked_manual(
self.state.get_many_unchecked_manual(
self.world,
entities,
self.last_change_tick,
@ -750,7 +750,7 @@ where
/// Returns the query items for the provided array of [`Entity`]
///
/// See [`Query::get_multiple_mut`] for the [`Result`]-returning equivalent.
/// See [`Query::get_many_mut`] for the [`Result`]-returning equivalent.
///
/// # Examples
///
@ -794,7 +794,7 @@ where
&mut self,
entities: [Entity; N],
) -> [<Q::Fetch as Fetch<'_, 's>>::Item; N] {
self.get_multiple_mut(entities).unwrap()
self.get_many_mut(entities).unwrap()
}
/// Returns the query result for the given [`Entity`].

2
crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_multiple_lifetime_safety.rs → crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_many_lifetime_safety.rs
View File

@ -4,7 +4,7 @@ use bevy_ecs::prelude::*;
struct A(usize);
fn system(mut query: Query<&mut A>, e: Res<Entity>) {
let a1 = query.get_multiple([*e, *e]).unwrap();
let a1 = query.get_many([*e, *e]).unwrap();
let a2 = query.get_mut(*e).unwrap();
// this should fail to compile
println!("{} {}", a1[0].0, a2.0);

6
crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_multiple_lifetime_safety.stderr → crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_many_lifetime_safety.stderr
View File

@ -1,8 +1,8 @@
error[E0502]: cannot borrow `query` as mutable because it is also borrowed as immutable
--> tests/ui/system_query_get_multiple_lifetime_safety.rs:8:14
--> tests/ui/system_query_get_many_lifetime_safety.rs:8:14
|
7 | let a1 = query.get_multiple([*e, *e]).unwrap();
| ---------------------------- immutable borrow occurs here
7 | let a1 = query.get_many([*e, *e]).unwrap();
| ------------------------ immutable borrow occurs here
8 | let a2 = query.get_mut(*e).unwrap();
| ^^^^^^^^^^^^^^^^^ mutable borrow occurs here
9 | // this should fail to compile

2
crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_multiple_mut_lifetime_safety.rs → crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_many_mut_lifetime_safety.rs
View File

@ -4,7 +4,7 @@ use bevy_ecs::prelude::*;
struct A(usize);
fn system(mut query: Query<&mut A>, e: Res<Entity>) {
let a1 = query.get_multiple_mut([*e, *e]).unwrap();
let a1 = query.get_many_mut([*e, *e]).unwrap();
let a2 = query.get_mut(*e).unwrap();
// this should fail to compile
println!("{} {}", a1[0].0, a2.0);

6
crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_multiple_mut_lifetime_safety.stderr → crates/bevy_ecs_compile_fail_tests/tests/ui/system_query_get_many_mut_lifetime_safety.stderr
View File

@ -1,8 +1,8 @@
error[E0499]: cannot borrow `query` as mutable more than once at a time
--> tests/ui/system_query_get_multiple_mut_lifetime_safety.rs:8:14
--> tests/ui/system_query_get_many_mut_lifetime_safety.rs:8:14
|
7 | let a1 = query.get_multiple_mut([*e, *e]).unwrap();
| -------------------------------- first mutable borrow occurs here
7 | let a1 = query.get_many_mut([*e, *e]).unwrap();
| ---------------------------- first mutable borrow occurs here
8 | let a2 = query.get_mut(*e).unwrap();
| ^^^^^^^^^^^^^^^^^ second mutable borrow occurs here
9 | // this should fail to compile