diff --git a/benches/benches/bevy_ecs/scheduling/run_condition.rs b/benches/benches/bevy_ecs/scheduling/run_condition.rs index 7f0100633d8f5..d6218efd6c9f1 100644 --- a/benches/benches/bevy_ecs/scheduling/run_condition.rs +++ b/benches/benches/bevy_ecs/scheduling/run_condition.rs @@ -68,7 +68,7 @@ pub fn run_condition_yes_with_query(criterion: &mut Criterion) { group.measurement_time(std::time::Duration::from_secs(3)); fn empty() {} fn yes_with_query(query: Query<&TestBool>) -> bool { - query.single().0 + query.get_single().unwrap().0 } for amount in 0..21 { let mut schedule = Schedule::default(); diff --git a/crates/bevy_ecs/compile_fail/tests/ui/query_lifetime_safety.rs b/crates/bevy_ecs/compile_fail/tests/ui/query_lifetime_safety.rs index a8db25b2235d3..905de0d8140e8 100644 --- a/crates/bevy_ecs/compile_fail/tests/ui/query_lifetime_safety.rs +++ b/crates/bevy_ecs/compile_fail/tests/ui/query_lifetime_safety.rs @@ -27,15 +27,15 @@ fn main() { } { - let data: &Foo = query.single(); - let mut data2: Mut = query.single_mut(); + let data: &Foo = query.get_single().unwrap(); + let mut data2: Mut = query.get_single_mut().unwrap(); //~^ E0502 assert_eq!(data, &mut *data2); // oops UB } { - let mut data2: Mut = query.single_mut(); - let data: &Foo = query.single(); + let mut data2: Mut = query.get_single_mut().unwrap(); + let data: &Foo = query.get_single().unwrap(); //~^ E0502 assert_eq!(data, &mut *data2); // oops UB } diff --git a/crates/bevy_ecs/compile_fail/tests/ui/query_to_readonly.rs b/crates/bevy_ecs/compile_fail/tests/ui/query_to_readonly.rs index 7e5a23cb2e361..0aba2eac627f8 100644 --- a/crates/bevy_ecs/compile_fail/tests/ui/query_to_readonly.rs +++ b/crates/bevy_ecs/compile_fail/tests/ui/query_to_readonly.rs @@ -35,14 +35,14 @@ fn for_loops(mut query: Query<&mut Foo>) { fn single_mut_query(mut query: Query<&mut Foo>) { // this should fail to compile { - let mut mut_foo = query.single_mut(); + let mut mut_foo = query.get_single_mut().unwrap(); // This solves "temporary value dropped while borrowed" let readonly_query = query.to_readonly(); //~^ E0502 - let ref_foo = readonly_query.single(); - + let ref_foo = readonly_query.get_single().unwrap(); + *mut_foo = Foo; println!("{ref_foo:?}"); @@ -53,9 +53,9 @@ fn single_mut_query(mut query: Query<&mut Foo>) { // This solves "temporary value dropped while borrowed" let readonly_query = query.to_readonly(); - let ref_foo = readonly_query.single(); + let ref_foo = readonly_query.get_single().unwrap(); - let mut mut_foo = query.single_mut(); + let mut mut_foo = query.get_single_mut().unwrap(); //~^ E0502 println!("{ref_foo:?}"); @@ -68,9 +68,9 @@ fn single_mut_query(mut query: Query<&mut Foo>) { // This solves "temporary value dropped while borrowed" let readonly_query = query.to_readonly(); - let readonly_foo = readonly_query.single(); + let readonly_foo = readonly_query.get_single().unwrap(); - let query_foo = query.single(); + let query_foo = query.get_single().unwrap(); println!("{readonly_foo:?}, {query_foo:?}"); } diff --git a/crates/bevy_ecs/compile_fail/tests/ui/query_transmute_safety.rs b/crates/bevy_ecs/compile_fail/tests/ui/query_transmute_safety.rs index 489c81d356bec..5b832c1be6948 100644 --- a/crates/bevy_ecs/compile_fail/tests/ui/query_transmute_safety.rs +++ b/crates/bevy_ecs/compile_fail/tests/ui/query_transmute_safety.rs @@ -22,8 +22,8 @@ fn main() { let mut query_a = lens_a.query(); let mut query_b = lens_b.query(); - let a = query_a.single_mut(); - let b = query_b.single_mut(); // oops 2 mutable references to same Foo + let a = query_a.get_single_mut().unwrap(); + let b = query_b.get_single_mut().unwrap(); // oops 2 mutable references to same Foo assert_eq!(*a, *b); } @@ -34,8 +34,8 @@ fn main() { let mut query_b = lens.query(); //~^ E0499 - let a = query_a.single_mut(); - let b = query_b.single_mut(); // oops 2 mutable references to same Foo + let a = query_a.get_single_mut().unwrap(); + let b = query_b.get_single_mut().unwrap(); // oops 2 mutable references to same Foo assert_eq!(*a, *b); } } diff --git a/crates/bevy_ecs/src/change_detection.rs b/crates/bevy_ecs/src/change_detection.rs index 03e8a40b55a02..97ac719727ef7 100644 --- a/crates/bevy_ecs/src/change_detection.rs +++ b/crates/bevy_ecs/src/change_detection.rs @@ -1068,11 +1068,11 @@ mod tests { #[test] fn change_expiration() { fn change_detected(query: Query>) -> bool { - query.single().is_changed() + query.get_single().unwrap().is_changed() } fn change_expired(query: Query>) -> bool { - query.single().is_changed() + query.get_single().unwrap().is_changed() } let mut world = World::new(); @@ -1114,7 +1114,7 @@ mod tests { // Since the world is always ahead, as long as changes can't get older than `u32::MAX` (which we ensure), // the wrapping difference will always be positive, so wraparound doesn't matter. let mut query = world.query::>(); - assert!(query.single(&world).is_changed()); + assert!(query.get_single(&world).unwrap().is_changed()); } #[test] diff --git a/crates/bevy_ecs/src/query/builder.rs b/crates/bevy_ecs/src/query/builder.rs index 101371d00400f..8941d97021d83 100644 --- a/crates/bevy_ecs/src/query/builder.rs +++ b/crates/bevy_ecs/src/query/builder.rs @@ -30,7 +30,7 @@ use super::{FilteredAccess, QueryData, QueryFilter}; /// .build(); /// /// // Consume the QueryState -/// let (entity, b) = query.single(&world); +/// let (entity, b) = query.get_single(&world); ///``` pub struct QueryBuilder<'w, D: QueryData = (), F: QueryFilter = ()> { access: FilteredAccess, @@ -272,13 +272,13 @@ mod tests { .with::() .without::() .build(); - assert_eq!(entity_a, query_a.single(&world)); + assert_eq!(entity_a, query_a.get_single(&world).unwrap()); let mut query_b = QueryBuilder::::new(&mut world) .with::() .without::() .build(); - assert_eq!(entity_b, query_b.single(&world)); + assert_eq!(entity_b, query_b.get_single(&world).unwrap()); } #[test] @@ -294,13 +294,13 @@ mod tests { .with_id(component_id_a) .without_id(component_id_c) .build(); - assert_eq!(entity_a, query_a.single(&world)); + assert_eq!(entity_a, query_a.get_single(&world).unwrap()); let mut query_b = QueryBuilder::::new(&mut world) .with_id(component_id_a) .without_id(component_id_b) .build(); - assert_eq!(entity_b, query_b.single(&world)); + assert_eq!(entity_b, query_b.get_single(&world).unwrap()); } #[test] @@ -360,7 +360,7 @@ mod tests { .data::<&B>() .build(); - let entity_ref = query.single(&world); + let entity_ref = query.get_single(&world).unwrap(); assert_eq!(entity, entity_ref.id()); @@ -383,7 +383,7 @@ mod tests { .ref_id(component_id_b) .build(); - let entity_ref = query.single(&world); + let entity_ref = query.get_single(&world).unwrap(); assert_eq!(entity, entity_ref.id()); diff --git a/crates/bevy_ecs/src/query/error.rs b/crates/bevy_ecs/src/query/error.rs index 1f1f33f2c4d56..1ce4b5a0f9d0c 100644 --- a/crates/bevy_ecs/src/query/error.rs +++ b/crates/bevy_ecs/src/query/error.rs @@ -22,7 +22,7 @@ pub enum QueryEntityError { } /// An error that occurs when evaluating a [`Query`](crate::system::Query) or [`QueryState`](crate::query::QueryState) as a single expected result via -/// [`get_single`](crate::system::Query::get_single) or [`get_single_mut`](crate::system::Query::get_single_mut). +/// [`get_single()`](crate::system::Query::get_single()) or [`single_mut`](crate::system::Query::single_mut). #[derive(Debug, Error)] pub enum QuerySingleError { /// No entity fits the query. diff --git a/crates/bevy_ecs/src/query/mod.rs b/crates/bevy_ecs/src/query/mod.rs index 4cc2b9f3458a8..fc89627d6dc7d 100644 --- a/crates/bevy_ecs/src/query/mod.rs +++ b/crates/bevy_ecs/src/query/mod.rs @@ -759,7 +759,7 @@ mod tests { let _: Option<&Foo> = q.get_manual(&world, e).ok(); let _: Option<[&Foo; 1]> = q.get_many(&world, [e]).ok(); let _: Option<&Foo> = q.get_single(&world).ok(); - let _: &Foo = q.single(&world); + let _: &Foo = q.get_single(&world).unwrap(); // system param let mut q = SystemState::>::new(&mut world); @@ -773,7 +773,7 @@ mod tests { let _: Option<[&Foo; 1]> = q.get_many([e]).ok(); let _: Option<&Foo> = q.get_single().ok(); let _: [&Foo; 1] = q.many([e]); - let _: &Foo = q.single(); + let _: &Foo = q.get_single().unwrap(); } // regression test for https://github.com/bevyengine/bevy/pull/8029 diff --git a/crates/bevy_ecs/src/query/state.rs b/crates/bevy_ecs/src/query/state.rs index dcb20250c2466..54d2610c7195f 100644 --- a/crates/bevy_ecs/src/query/state.rs +++ b/crates/bevy_ecs/src/query/state.rs @@ -1514,25 +1514,6 @@ impl QueryState { }); } - /// Returns a single immutable query result when there is exactly one entity matching - /// the query. - /// - /// This can only be called for read-only queries, - /// see [`single_mut`](Self::single_mut) for write-queries. - /// - /// # Panics - /// - /// Panics if the number of query results is not exactly one. Use - /// [`get_single`](Self::get_single) to return a `Result` instead of panicking. - #[track_caller] - #[inline] - pub fn single<'w>(&mut self, world: &'w World) -> ROQueryItem<'w, D> { - match self.get_single(world) { - Ok(items) => items, - Err(error) => panic!("Cannot get single mutable query result: {error}"), - } - } - /// Returns a single immutable query result when there is exactly one entity matching /// the query. /// @@ -1550,7 +1531,7 @@ impl QueryState { // SAFETY: query is read only unsafe { - self.as_readonly().get_single_unchecked_manual( + self.as_readonly().single_unchecked_manual( world.as_unsafe_world_cell_readonly(), world.last_change_tick(), world.read_change_tick(), @@ -1558,23 +1539,6 @@ impl QueryState { } } - /// Returns a single mutable query result when there is exactly one entity matching - /// the query. - /// - /// # Panics - /// - /// Panics if the number of query results is not exactly one. Use - /// [`get_single_mut`](Self::get_single_mut) to return a `Result` instead of panicking. - #[track_caller] - #[inline] - pub fn single_mut<'w>(&mut self, world: &'w mut World) -> D::Item<'w> { - // SAFETY: query has unique world access - match self.get_single_mut(world) { - Ok(items) => items, - Err(error) => panic!("Cannot get single query result: {error}"), - } - } - /// Returns a single mutable query result when there is exactly one entity matching /// the query. /// @@ -1591,7 +1555,7 @@ impl QueryState { let last_change_tick = world.last_change_tick(); // SAFETY: query has unique world access unsafe { - self.get_single_unchecked_manual( + self.single_unchecked_manual( world.as_unsafe_world_cell(), last_change_tick, change_tick, @@ -1609,12 +1573,12 @@ impl QueryState { /// This does not check for mutable query correctness. To be safe, make sure mutable queries /// have unique access to the components they query. #[inline] - pub unsafe fn get_single_unchecked<'w>( + pub unsafe fn single_unchecked<'w>( &mut self, world: UnsafeWorldCell<'w>, ) -> Result, QuerySingleError> { self.update_archetypes_unsafe_world_cell(world); - self.get_single_unchecked_manual(world, world.last_change_tick(), world.change_tick()) + self.single_unchecked_manual(world, world.last_change_tick(), world.change_tick()) } /// Returns a query result when there is exactly one entity matching the query, @@ -1628,7 +1592,7 @@ impl QueryState { /// This does not check for mutable query correctness. To be safe, make sure mutable queries /// have unique access to the components they query. #[inline] - pub unsafe fn get_single_unchecked_manual<'w>( + pub unsafe fn single_unchecked_manual<'w>( &self, world: UnsafeWorldCell<'w>, last_run: Tick, @@ -1781,7 +1745,7 @@ mod tests { let query_state = world.query::<(&A, &B)>(); let mut new_query_state = query_state.transmute::<&A>(world.components()); assert_eq!(new_query_state.iter(&world).len(), 1); - let a = new_query_state.single(&world); + let a = new_query_state.get_single(&world).unwrap(); assert_eq!(a.0, 1); } @@ -1795,7 +1759,7 @@ mod tests { let query_state = world.query_filtered::<(&A, &B), Without>(); let mut new_query_state = query_state.transmute::<&A>(world.components()); // even though we change the query to not have Without, we do not get the component with C. - let a = new_query_state.single(&world); + let a = new_query_state.get_single(&world).unwrap(); assert_eq!(a.0, 0); } @@ -1808,7 +1772,7 @@ mod tests { let q = world.query::<()>(); let mut q = q.transmute::(world.components()); - assert_eq!(q.single(&world), entity); + assert_eq!(q.get_single(&world).unwrap(), entity); } #[test] @@ -1818,7 +1782,7 @@ mod tests { let q = world.query::<&A>(); let mut new_q = q.transmute::>(world.components()); - assert!(new_q.single(&world).is_added()); + assert!(new_q.get_single(&world).unwrap().is_added()); let q = world.query::>(); let _ = q.transmute::<&A>(world.components()); @@ -1889,7 +1853,7 @@ mod tests { let query_state = world.query::>(); let mut new_query_state = query_state.transmute::<&A>(world.components()); - let x = new_query_state.single(&world); + let x = new_query_state.get_single(&world).unwrap(); assert_eq!(x.0, 1234); } @@ -1914,7 +1878,7 @@ mod tests { let mut query = query; // Our result is completely untyped - let entity_ref = query.single(&world); + let entity_ref = query.get_single(&world).unwrap(); assert_eq!(entity, entity_ref.id()); assert_eq!(0, entity_ref.get::().unwrap().0); @@ -1929,12 +1893,12 @@ mod tests { let mut query = QueryState::<(Entity, &A, Has)>::new(&mut world) .transmute_filtered::<(Entity, Has), Added>(world.components()); - assert_eq!((entity_a, false), query.single(&world)); + assert_eq!((entity_a, false), query.get_single(&world).unwrap()); world.clear_trackers(); let entity_b = world.spawn((A(0), B(0))).id(); - assert_eq!((entity_b, true), query.single(&world)); + assert_eq!((entity_b, true), query.get_single(&world).unwrap()); world.clear_trackers(); @@ -1950,15 +1914,15 @@ mod tests { .transmute_filtered::>(world.components()); let mut change_query = QueryState::<&mut A>::new(&mut world); - assert_eq!(entity_a, detection_query.single(&world)); + assert_eq!(entity_a, detection_query.get_single(&world).unwrap()); world.clear_trackers(); assert!(detection_query.get_single(&world).is_err()); - change_query.single_mut(&mut world).0 = 1; + change_query.get_single_mut(&mut world).unwrap().0 = 1; - assert_eq!(entity_a, detection_query.single(&world)); + assert_eq!(entity_a, detection_query.get_single(&world).unwrap()); } #[test] @@ -1986,7 +1950,7 @@ mod tests { let mut new_query: QueryState = query_1.join_filtered(world.components(), &query_2); - assert_eq!(new_query.single(&world), entity_ab); + assert_eq!(new_query.get_single(&world).unwrap(), entity_ab); } #[test] diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs index d2cf03a96eda0..c557c3733fd14 100644 --- a/crates/bevy_ecs/src/system/mod.rs +++ b/crates/bevy_ecs/src/system/mod.rs @@ -1185,7 +1185,7 @@ mod tests { let (a, query, _) = system_state.get(&world); assert_eq!(*a, A(42), "returned resource matches initial value"); assert_eq!( - *query.single(), + *query.get_single().unwrap(), B(7), "returned component matches initial value" ); @@ -1212,7 +1212,7 @@ mod tests { let (a, mut query) = system_state.get_mut(&mut world); assert_eq!(*a, A(42), "returned resource matches initial value"); assert_eq!( - *query.single_mut(), + *query.get_single_mut().unwrap(), B(7), "returned component matches initial value" ); @@ -1229,7 +1229,7 @@ mod tests { let mut system_state: SystemState>> = SystemState::new(&mut world); { let query = system_state.get(&world); - assert_eq!(*query.single(), A(1)); + assert_eq!(*query.get_single().unwrap(), A(1)); } { @@ -1240,7 +1240,7 @@ mod tests { world.entity_mut(entity).get_mut::().unwrap().0 = 2; { let query = system_state.get(&world); - assert_eq!(*query.single(), A(2)); + assert_eq!(*query.get_single().unwrap(), A(2)); } } diff --git a/crates/bevy_ecs/src/system/query.rs b/crates/bevy_ecs/src/system/query.rs index 215c8d7b1108b..0493628f080c5 100644 --- a/crates/bevy_ecs/src/system/query.rs +++ b/crates/bevy_ecs/src/system/query.rs @@ -244,7 +244,7 @@ use std::borrow::Borrow; /// |[`iter_combinations`]\[[`_mut`][`iter_combinations_mut`]]|Returns an iterator over all combinations of a specified number of query items.| /// |[`get`]\[[`_mut`][`get_mut`]]|Returns the query item for the specified entity.| /// |[`many`]\[[`_mut`][`many_mut`]],
[`get_many`]\[[`_mut`][`get_many_mut`]]|Returns the query items for the specified entities.| -/// |[`single`]\[[`_mut`][`single_mut`]],
[`get_single`]\[[`_mut`][`get_single_mut`]]|Returns the query item while verifying that there aren't others.| +/// |[`single`]\[[`_mut`][`single_mut`]],
[`get_single()`]\[[`_mut`][`single_mut`]]|Returns the query item while verifying that there aren't others.| /// /// There are two methods for each type of query operation: immutable and mutable (ending with `_mut`). /// When using immutable methods, the query items returned are of type [`ROQueryItem`], a read-only version of the query item. @@ -281,7 +281,7 @@ use std::borrow::Borrow; /// |[`get`]\[[`_mut`][`get_mut`]]|O(1)| /// |([`get_`][`get_many`])[`many`]|O(k)| /// |([`get_`][`get_many_mut`])[`many_mut`]|O(k2)| -/// |[`single`]\[[`_mut`][`single_mut`]],
[`get_single`]\[[`_mut`][`get_single_mut`]]|O(a)| +/// |[`single`]\[[`_mut`][`single_mut`]],
[`get_single()`]\[[`_mut`][`single_mut`]]|O(a)| /// |Archetype based filtering ([`With`], [`Without`], [`Or`])|O(a)| /// |Change detection filtering ([`Added`], [`Changed`])|O(a + n)| /// @@ -325,8 +325,8 @@ use std::borrow::Borrow; /// [`get_many`]: Self::get_many /// [`get_many_mut`]: Self::get_many_mut /// [`get_mut`]: Self::get_mut -/// [`get_single`]: Self::get_single -/// [`get_single_mut`]: Self::get_single_mut +/// [`get_single()`]: Self::get_single() +/// [`single_mut`]: Self::single_mut /// [`iter`]: Self::iter /// [`iter_combinations`]: Self::iter_combinations /// [`iter_combinations_mut`]: Self::iter_combinations_mut @@ -1071,36 +1071,6 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { } } - /// Returns a single read-only query item when there is exactly one entity matching the query. - /// - /// # Panics - /// - /// This method panics if the number of query items is **not** exactly one. - /// - /// # Example - /// - /// ``` - /// # use bevy_ecs::prelude::*; - /// # #[derive(Component)] - /// # struct Player; - /// # #[derive(Component)] - /// # struct Position(f32, f32); - /// fn player_system(query: Query<&Position, With>) { - /// let player_position = query.single(); - /// // do something with player_position - /// } - /// # bevy_ecs::system::assert_is_system(player_system); - /// ``` - /// - /// # See also - /// - /// - [`get_single`](Self::get_single) for the non-panicking version. - /// - [`single_mut`](Self::single_mut) to get the mutable query item. - #[track_caller] - pub fn single(&self) -> ROQueryItem<'_, D> { - self.get_single().unwrap() - } - /// Returns a single read-only query item when there is exactly one entity matching the query. /// /// If the number of query items is not exactly one, a [`QuerySingleError`] is returned instead. @@ -1113,7 +1083,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { /// # #[derive(Component)] /// # struct PlayerScore(i32); /// fn player_scoring_system(query: Query<&PlayerScore>) { - /// match query.get_single() { + /// match query.get_single().unwrap() { /// Ok(PlayerScore(score)) => { /// println!("Score: {}", score); /// } @@ -1131,14 +1101,13 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { /// # See also /// /// - [`get_single_mut`](Self::get_single_mut) to get the mutable query item. - /// - [`single`](Self::single) for the panicking version. #[inline] pub fn get_single(&self) -> Result, QuerySingleError> { // SAFETY: // the query ensures that the components it accesses are not mutably accessible somewhere else // and the query is read only. unsafe { - self.state.as_readonly().get_single_unchecked_manual( + self.state.as_readonly().single_unchecked_manual( self.world, self.last_run, self.this_run, @@ -1146,38 +1115,6 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { } } - /// Returns a single query item when there is exactly one entity matching the query. - /// - /// # Panics - /// - /// This method panics if the number of query items is **not** exactly one. - /// - /// # Example - /// - /// ``` - /// # use bevy_ecs::prelude::*; - /// # - /// # #[derive(Component)] - /// # struct Player; - /// # #[derive(Component)] - /// # struct Health(u32); - /// # - /// fn regenerate_player_health_system(mut query: Query<&mut Health, With>) { - /// let mut health = query.single_mut(); - /// health.0 += 1; - /// } - /// # bevy_ecs::system::assert_is_system(regenerate_player_health_system); - /// ``` - /// - /// # See also - /// - /// - [`get_single_mut`](Self::get_single_mut) for the non-panicking version. - /// - [`single`](Self::single) to get the read-only query item. - #[track_caller] - pub fn single_mut(&mut self) -> D::Item<'_> { - self.get_single_mut().unwrap() - } - /// Returns a single query item when there is exactly one entity matching the query. /// /// If the number of query items is not exactly one, a [`QuerySingleError`] is returned instead. @@ -1193,7 +1130,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { /// # struct Health(u32); /// # /// fn regenerate_player_health_system(mut query: Query<&mut Health, With>) { - /// let mut health = query.get_single_mut().expect("Error: Could not find a single player."); + /// let mut health = query.get_single_mut().unwrap().expect("Error: Could not find a single player."); /// health.0 += 1; /// } /// # bevy_ecs::system::assert_is_system(regenerate_player_health_system); @@ -1202,7 +1139,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { /// # See also /// /// - [`get_single`](Self::get_single) to get the read-only query item. - /// - [`single_mut`](Self::single_mut) for the panicking version. + /// - [`get_single_mut`](Self::get_single_mut) for the panicking version. #[inline] pub fn get_single_mut(&mut self) -> Result, QuerySingleError> { // SAFETY: @@ -1210,7 +1147,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { // is uniquely borrowed unsafe { self.state - .get_single_unchecked_manual(self.world, self.last_run, self.this_run) + .single_unchecked_manual(self.world, self.last_run, self.this_run) } } @@ -1318,7 +1255,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> { /// # world.spawn((A(10), B(5))); /// # /// fn reusable_function(lens: &mut QueryLens<&A>) { - /// assert_eq!(lens.query().single().0, 10); + /// assert_eq!(lens.query().get_single().unwrap().0, 10); /// } /// /// // We can use the function in a system that takes the exact query. diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs index 415b62e0ad820..f4983d94e0258 100644 --- a/crates/bevy_ecs/src/system/system_param.rs +++ b/crates/bevy_ecs/src/system/system_param.rs @@ -945,7 +945,7 @@ pub trait SystemBuffer: FromWorld + Send + 'static { /// criminals: Query<&Criminal>, /// mut alarm: Deferred /// ) { -/// let settlement = settlements.single(); +/// let settlement = settlements.get_single().unwrap(); /// for criminal in &criminals { /// // Only sound the alarm if the criminal is a threat. /// // For this example, assume that this check is expensive to run. diff --git a/crates/bevy_ecs/src/world/entity_ref.rs b/crates/bevy_ecs/src/world/entity_ref.rs index 2d1073e0fd09f..3aaa75a6aa298 100644 --- a/crates/bevy_ecs/src/world/entity_ref.rs +++ b/crates/bevy_ecs/src/world/entity_ref.rs @@ -1389,11 +1389,11 @@ impl<'w> EntityWorldMut<'w> { /// let mut entity = world.spawn_empty(); /// entity.entry().or_insert_with(|| Comp(4)); /// # let entity_id = entity.id(); - /// assert_eq!(world.query::<&Comp>().single(&world).0, 4); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 4); /// /// # let mut entity = world.get_entity_mut(entity_id).unwrap(); /// entity.entry::().and_modify(|mut c| c.0 += 1); - /// assert_eq!(world.query::<&Comp>().single(&world).0, 5); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 5); /// /// ``` pub fn entry<'a, T: Component>(&'a mut self) -> Entry<'w, 'a, T> { @@ -1461,7 +1461,7 @@ impl<'w, 'a, T: Component> Entry<'w, 'a, T> { /// let mut entity = world.spawn(Comp(0)); /// /// entity.entry::().and_modify(|mut c| c.0 += 1); - /// assert_eq!(world.query::<&Comp>().single(&world).0, 1); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 1); /// ``` #[inline] pub fn and_modify)>(self, f: F) -> Self { @@ -1518,11 +1518,11 @@ impl<'w, 'a, T: Component> Entry<'w, 'a, T> { /// /// entity.entry().or_insert(Comp(4)); /// # let entity_id = entity.id(); - /// assert_eq!(world.query::<&Comp>().single(&world).0, 4); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 4); /// /// # let mut entity = world.get_entity_mut(entity_id).unwrap(); /// entity.entry().or_insert(Comp(15)).0 *= 2; - /// assert_eq!(world.query::<&Comp>().single(&world).0, 8); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 8); /// ``` #[inline] pub fn or_insert(self, default: T) -> Mut<'a, T> { @@ -1546,7 +1546,7 @@ impl<'w, 'a, T: Component> Entry<'w, 'a, T> { /// let mut entity = world.spawn_empty(); /// /// entity.entry().or_insert_with(|| Comp(4)); - /// assert_eq!(world.query::<&Comp>().single(&world).0, 4); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 4); /// ``` #[inline] pub fn or_insert_with T>(self, default: F) -> Mut<'a, T> { @@ -1572,7 +1572,7 @@ impl<'w, 'a, T: Component + Default> Entry<'w, 'a, T> { /// let mut entity = world.spawn_empty(); /// /// entity.entry::().or_default(); - /// assert_eq!(world.query::<&Comp>().single(&world).0, 0); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 0); /// ``` #[inline] pub fn or_default(self) -> Mut<'a, T> { @@ -1639,7 +1639,7 @@ impl<'w, 'a, T: Component> OccupiedEntry<'w, 'a, T> { /// o.get_mut().0 += 2 /// } /// - /// assert_eq!(world.query::<&Comp>().single(&world).0, 17); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 17); /// ``` #[inline] pub fn get_mut(&mut self) -> Mut<'_, T> { @@ -1668,7 +1668,7 @@ impl<'w, 'a, T: Component> OccupiedEntry<'w, 'a, T> { /// o.into_mut().0 += 10; /// } /// - /// assert_eq!(world.query::<&Comp>().single(&world).0, 15); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 15); /// ``` #[inline] pub fn into_mut(self) -> Mut<'a, T> { @@ -1692,7 +1692,7 @@ impl<'w, 'a, T: Component> OccupiedEntry<'w, 'a, T> { /// o.insert(Comp(10)); /// } /// - /// assert_eq!(world.query::<&Comp>().single(&world).0, 10); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 10); /// ``` #[inline] pub fn insert(&mut self, component: T) { @@ -1747,7 +1747,7 @@ impl<'w, 'a, T: Component> VacantEntry<'w, 'a, T> { /// v.insert(Comp(10)); /// } /// - /// assert_eq!(world.query::<&Comp>().single(&world).0, 10); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 10); /// ``` #[inline] pub fn insert(self, component: T) -> Mut<'a, T> { @@ -1772,7 +1772,7 @@ impl<'w, 'a, T: Component> VacantEntry<'w, 'a, T> { /// v.insert_entry(Comp(10)); /// } /// - /// assert_eq!(world.query::<&Comp>().single(&world).0, 10); + /// assert_eq!(world.query::<&Comp>().get_single(&world).0, 10); /// ``` #[inline] pub fn insert_entry(self, component: T) -> OccupiedEntry<'w, 'a, T> { diff --git a/crates/bevy_hierarchy/src/query_extension.rs b/crates/bevy_hierarchy/src/query_extension.rs index 4525a3ea5dcf5..e18176a4c6336 100644 --- a/crates/bevy_hierarchy/src/query_extension.rs +++ b/crates/bevy_hierarchy/src/query_extension.rs @@ -23,7 +23,7 @@ pub trait HierarchyQueryExt<'w, 's, D: QueryData, F: QueryFilter> { /// # #[derive(Component)] /// # struct Marker; /// fn system(query: Query>, children_query: Query<&Children>) { - /// let entity = query.single(); + /// let entity = query.get_single().unwrap(); /// for descendant in children_query.iter_descendants(entity) { /// // Do something! /// } @@ -45,7 +45,7 @@ pub trait HierarchyQueryExt<'w, 's, D: QueryData, F: QueryFilter> { /// # #[derive(Component)] /// # struct Marker; /// fn system(query: Query>, parent_query: Query<&Parent>) { - /// let entity = query.single(); + /// let entity = query.get_single().unwrap(); /// for ancestor in parent_query.iter_ancestors(entity) { /// // Do something! /// } diff --git a/crates/bevy_scene/src/bundle.rs b/crates/bevy_scene/src/bundle.rs index a154acdccdaa5..33c5eba7d6fee 100644 --- a/crates/bevy_scene/src/bundle.rs +++ b/crates/bevy_scene/src/bundle.rs @@ -157,7 +157,8 @@ mod tests { let (scene_entity, scene_component_a) = app .world_mut() .query::<(Entity, &ComponentA)>() - .single(app.world()); + .get_single(app.world()) + .unwrap(); assert_eq!(scene_component_a.x, 3.0); assert_eq!(scene_component_a.y, 4.0); assert_eq!( diff --git a/crates/bevy_scene/src/scene_spawner.rs b/crates/bevy_scene/src/scene_spawner.rs index 45791eb1d61a7..c9117a0806e0a 100644 --- a/crates/bevy_scene/src/scene_spawner.rs +++ b/crates/bevy_scene/src/scene_spawner.rs @@ -500,7 +500,10 @@ mod tests { // clone only existing entity let mut scene_spawner = SceneSpawner::default(); - let entity = world.query_filtered::>().single(&world); + let entity = world + .query_filtered::>() + .get_single(&world) + .unwrap(); let scene = DynamicSceneBuilder::from_world(&world) .extract_entity(entity) .build(); diff --git a/crates/bevy_winit/src/state.rs b/crates/bevy_winit/src/state.rs index 8b866d59799c1..e22978242712b 100644 --- a/crates/bevy_winit/src/state.rs +++ b/crates/bevy_winit/src/state.rs @@ -443,7 +443,7 @@ impl ApplicationHandler for WinitAppRunnerState { let mut query = self .world_mut() .query_filtered::>(); - let entity = query.single(&self.world()); + let entity = query.get_single(&self.world()); self.world_mut() .entity_mut(entity) .remove::(); @@ -463,7 +463,7 @@ impl ApplicationHandler for WinitAppRunnerState { // handle wrapper removed when the app was suspended. let mut query = self.world_mut() .query_filtered::<(Entity, &Window), (With, Without)>(); - if let Ok((entity, window)) = query.get_single(&self.world()) { + if let Ok((entity, window)) = query.get_single()(&self.world()) { let window = window.clone(); let mut create_window = diff --git a/examples/2d/2d_viewport_to_world.rs b/examples/2d/2d_viewport_to_world.rs index 788649f9793c0..312e6c0b8a17c 100644 --- a/examples/2d/2d_viewport_to_world.rs +++ b/examples/2d/2d_viewport_to_world.rs @@ -15,9 +15,9 @@ fn draw_cursor( windows: Query<&Window>, mut gizmos: Gizmos, ) { - let (camera, camera_transform) = camera_query.single(); + let (camera, camera_transform) = camera_query.get_single().unwrap(); - let Some(cursor_position) = windows.single().cursor_position() else { + let Some(cursor_position) = windows.get_single().unwrap().cursor_position() else { return; }; diff --git a/examples/2d/bloom_2d.rs b/examples/2d/bloom_2d.rs index 3735fcf3000e4..ea6e585bc1c63 100644 --- a/examples/2d/bloom_2d.rs +++ b/examples/2d/bloom_2d.rs @@ -84,8 +84,8 @@ fn update_bloom_settings( keycode: Res>, time: Res