feat: implement WithoutOne as counterpart for WithOne

Author: RobWalt

src/one.rs

@@ -850,3 +850,95 @@ impl<Trait: ?Sized + TraitQuery> QueryFilter for WithOne<Trait> {
         true
     }
 }
+
+/// [`WorldQuery`] filter for entities without any [one](crate::One) component
+/// implementing a trait.
+pub struct WithoutOne<Trait: ?Sized + TraitQuery>(PhantomData<&'static Trait>);
+
+// this takes inspiration from `With` in bevy's main repo
+unsafe impl<Trait: ?Sized + TraitQuery> WorldQuery for WithoutOne<Trait> {
+    type Item<'w> = ();
+    type Fetch<'w> = ();
+    type State = TraitQueryState<Trait>;
+
+    #[inline]
+    fn shrink<'wlong: 'wshort, 'wshort>(item: QueryItem<'wlong, Self>) -> QueryItem<'wshort, Self> {
+        item
+    }
+
+    #[inline]
+    unsafe fn init_fetch(
+        _world: UnsafeWorldCell<'_>,
+        _state: &Self::State,
+        _last_run: Tick,
+        _this_run: Tick,
+    ) {
+    }
+
+    const IS_DENSE: bool = false;
+
+    #[inline]
+    unsafe fn set_archetype<'w>(
+        _fetch: &mut (),
+        _state: &Self::State,
+        _archetype: &'w bevy_ecs::archetype::Archetype,
+        _table: &'w bevy_ecs::storage::Table,
+    ) {
+    }
+
+    #[inline]
+    unsafe fn set_table(_fetch: &mut (), _state: &Self::State, _table: &bevy_ecs::storage::Table) {}
+
+    #[inline]
+    unsafe fn fetch<'w>(
+        _fetch: &mut Self::Fetch<'w>,
+        _entity: Entity,
+        _table_row: TableRow,
+    ) -> Self::Item<'w> {
+    }
+
+    #[inline]
+    fn update_component_access(
+        state: &Self::State,
+        access: &mut bevy_ecs::query::FilteredAccess<ComponentId>,
+    ) {
+        for &component in &*state.components {
+            assert!(
+                !access.access().has_write(component),
+                "&{} conflicts with a previous access in this query. Shared access cannot coincide with exclusive access.",
+                std::any::type_name::<Trait>(),
+            );
+            access.and_without(component);
+        }
+    }
+
+    #[inline]
+    fn init_state(world: &mut World) -> Self::State {
+        TraitQueryState::init(world)
+    }
+
+    #[inline]
+    fn get_state(world: &World) -> Option<Self::State> {
+        TraitQueryState::get(world)
+    }
+
+    #[inline]
+    fn matches_component_set(
+        state: &Self::State,
+        set_contains_id: &impl Fn(ComponentId) -> bool,
+    ) -> bool {
+        !state.components.iter().any(|&id| set_contains_id(id))
+    }
+}
+
+/// SAFETY: read-only access
+impl<Trait: ?Sized + TraitQuery> QueryFilter for WithoutOne<Trait> {
+    const IS_ARCHETYPAL: bool = false;
+    unsafe fn filter_fetch(
+        _fetch: &mut Self::Fetch<'_>,
+        _entity: Entity,
+        _table_row: TableRow,
+    ) -> bool {
+        true
+    }
+}

src/tests.rs

@@ -537,6 +537,44 @@ fn print_with_one_filter_info(
     output.0.push(Default::default());
 }
 
+#[test]
+fn without_any_filter() {
+    let mut world = World::new();
+    world.init_resource::<Output>();
+    world
+        .register_component_as::<dyn Person, Human>()
+        .register_component_as::<dyn Person, Dolphin>();
+
+    world.spawn(Human("Henry".to_owned(), 22));
+    world.spawn((Human("Henry".to_owned(), 22), Dolphin(22)));
+    world.spawn(Dolphin(22));
+    world.spawn(Fem);
+
+    let mut schedule = Schedule::default();
+    schedule.add_systems(print_without_any_filter_info);
+
+    schedule.run(&mut world);
+
+    assert_eq!(
+        world.resource::<Output>().0,
+        &["People that are neither Human or Dolphin:", "3v1", "",]
+    );
+}
+
+// Prints the entity id of every Entity where none of its components implement the trait
+fn print_without_any_filter_info(
+    people: Query<Entity, WithoutOne<dyn Person>>,
+    mut output: ResMut<Output>,
+) {
+    output
+        .0
+        .push("People that are neither Human or Dolphin:".to_string());
+    for person in (&people).into_iter() {
+        output.0.push(format!("{person:?}"));
+    }
+    output.0.push(Default::default());
+}
+
 #[queryable]
 pub trait Messages {
     fn send(&mut self, _: &dyn Display);