ecs: Remove GATs from QueryDriver

This splits query lifetimes in two: 'w is the lifetime of the ECS and 'q is the lifetime
of the query. Additionally, QueryDriver::iter now returns a struct instead of an impl Iterator.
These changes allow GATs to be removed from the QueryDriver implementation.

Author: caelunshun

quill/ecs/src/ecs.rs

@@ -9,7 +9,7 @@ use crate::{
     entity::{Entities, EntityId},
     entity_builder::EntityBuilder,
     storage::SparseSetStorage,
-    QueryDriver, QueryTuple,
+    QueryDriver,
 };
 
 pub use self::components::Components;
@@ -140,6 +140,7 @@ impl Ecs {
         Ok(())
     }
 
+    /*
     /// Queries for all entities that have the given set of components.
     ///
     /// Returns an iterator over tuples of `(entity, components)`.
@@ -164,6 +165,7 @@ impl Ecs {
             (entity, components)
         }))
     }
+    */
 
     fn check_entity(&self, entity: EntityId) -> Result<(), EntityDead> {
         self.entities

quill/ecs/src/lib.rs

@@ -1,7 +1,5 @@
 #![allow(unused)] // TEMP (remove before merge)
 #![allow(unstable_name_collisions)]
-#![feature(generic_associated_types)] // TEMP: need to figure out how to remove this before merge (needed for queries)
-#![allow(incomplete_features)]
 
 mod borrow;
 mod bundle;
@@ -17,5 +15,5 @@ pub use component::Component;
 pub use ecs::{ComponentError, Components, Ecs, EntityDead};
 pub use entity::EntityId;
 pub use entity_builder::EntityBuilder;
-pub use query::{QueryDriver, QueryItem, QueryParameter, QueryTuple};
+pub use query::{QueryDriver, QueryItem};
 pub use storage::{SparseSetRef, SparseSetStorage};

quill/ecs/src/query.rs

@@ -2,32 +2,32 @@
 
 use std::{any::TypeId, cell::Cell, ops::Deref};
 
-use crate::{Component, Components, Ecs, SparseSetRef, SparseSetStorage};
+use crate::{storage::sparse_set, Component, Components, Ecs, SparseSetRef, SparseSetStorage};
 
 /// Drives a query by yielding the entities
 /// whose components satisfy the query parameters.
-pub struct QueryDriver<'a> {
+pub struct QueryDriver<'w, 'q> {
     /// A sparse set for each component in the query.
-    sparse_sets: &'a [SparseSetRef<'a>],
+    sparse_sets: &'q [SparseSetRef<'w>],
 
     /// The "lead" sparse set, chosen as the set with
     /// the smallest number of components.
-    lead: SparseSetRef<'a>,
+    lead: SparseSetRef<'q>,
 
     /// Used as the yielded value for the iterator.
     /// (We can't own this because of the lack of GATs.)
-    dense_indices: &'a [Cell<u32>],
+    dense_indices: &'q [Cell<u32>],
 }
 
-impl<'a> QueryDriver<'a> {
+impl<'w, 'q> QueryDriver<'w, 'q> {
     /// Creates a new `QueryDriver` given the sparse sets
     /// whose components are required by the query.
     ///
     /// `dense_indices` should be a zeroed slice of size `sparse_sets.len()`.
     ///
     /// # Panics
     /// Panics if `sparse_sets.len() != dense_indices.len()`.
-    pub fn new(sparse_sets: &'a [SparseSetRef<'a>], dense_indices: &'a [Cell<u32>]) -> Self {
+    pub fn new(sparse_sets: &'q [SparseSetRef<'w>], dense_indices: &'q [Cell<u32>]) -> Self {
         let lead = sparse_sets
             .iter()
             .min_by_key(|set| set.len())
@@ -45,49 +45,69 @@ impl<'a> QueryDriver<'a> {
         self.sparse_sets.len()
     }
 
-    /// Iterates over all `QueryItem`s yielded by the query.
-    pub fn iter(&mut self) -> impl Iterator<Item = QueryItem<'a>> + '_ {
-        let Self {
-            lead,
-            dense_indices,
-            sparse_sets,
-        } = self;
-        lead.iter()
-            .filter_map(move |(entity_index, dense_in_lead)| {
-                for (i, (index, sparse_set)) in
-                    dense_indices.iter().zip(sparse_sets.iter()).enumerate()
-                {
-                    index.set(sparse_set.dense_index_of(entity_index)?);
-                }
-
-                Some(QueryItem {
-                    sparse_index: entity_index,
-                    dense_indices,
-                })
-            })
+    /// Iterates over dense and sparse indices matching the query.
+    pub fn iter(&'q mut self) -> QueryDriverIter<'w, 'q> {
+        QueryDriverIter {
+            lead_iter: self.lead.iter(),
+            driver: self,
+        }
+    }
+}
+
+/// An iterator for a QueryDriver.
+pub struct QueryDriverIter<'w, 'q> {
+    driver: &'q mut QueryDriver<'w, 'q>,
+    lead_iter: sparse_set::Iter<'q>,
+}
+
+impl<'w, 'q> Iterator for QueryDriverIter<'w, 'q> {
+    type Item = QueryItem<'q>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let (sparse_index, lead_dense_index) = self.lead_iter.next()?;
+
+            for (dense_index, sparse_set) in self
+                .driver
+                .dense_indices
+                .iter()
+                .zip(self.driver.sparse_sets.iter())
+            {
+                dense_index.set(match sparse_set.dense_index_of(sparse_index) {
+                    Some(d) => d,
+                    None => continue,
+                });
+            }
+
+            break Some(QueryItem {
+                dense_indices: &self.driver.dense_indices,
+                sparse_index,
+            });
+        }
     }
 }
 
 /// An item yielded by a query.
-pub struct QueryItem<'a> {
+pub struct QueryItem<'q> {
     /// The `dense` index into the sparse set
     /// of each component in the query.
-    pub dense_indices: &'a [Cell<u32>],
+    pub dense_indices: &'q [Cell<u32>],
     /// The sparse (entity) index of this item.
     pub sparse_index: u32,
 }
 
 // -- Static queries
 
+/*
 /// A typed query element.
 pub trait QueryParameter {
-    type Output<'a>;
+    type Output;
     type Component: Component;
 
     unsafe fn get_unchecked_by_dense_index(
         storage: &SparseSetStorage,
         dense_index: u32,
-    ) -> Self::Output<'_>;
+    ) -> Self::Output;
 }
 
 impl<'a, T> QueryParameter for &'a T
@@ -159,3 +179,4 @@ macro_rules! query_tuple_impl {
 }
 
 query_tuple_impl!(1, (T1, 0));
+*/

quill/ecs/src/storage.rs

@@ -1,5 +1,5 @@
 mod blob_array;
 mod component_vec;
-mod sparse_set;
+pub(crate) mod sparse_set;
 
 pub use sparse_set::{SparseSetRef, SparseSetStorage};

quill/ecs/src/storage/sparse_set.rs

@@ -1,4 +1,10 @@
-use std::{any::TypeId, iter, mem::MaybeUninit, ptr::NonNull};
+use core::slice;
+use std::{
+    any::TypeId,
+    iter::{self, Enumerate},
+    mem::MaybeUninit,
+    ptr::NonNull,
+};
 
 use crate::{
     borrow::BorrowFlag,
@@ -166,11 +172,23 @@ impl<'a> SparseSetRef<'a> {
     }
 
     /// Returns an iterator over (sparse_index, dense_index) within this sparse set.
-    pub fn iter(&self) -> impl Iterator<Item = (u32, u32)> + '_ {
-        self.dense
-            .iter()
-            .enumerate()
-            .map(|(dense_index, &sparse_index)| (sparse_index, dense_index as u32))
+    pub fn iter(&self) -> Iter<'a> {
+        Iter {
+            inner: self.dense.iter().enumerate(),
+        }
+    }
+}
+
+pub struct Iter<'a> {
+    inner: Enumerate<slice::Iter<'a, u32>>,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = (u32, u32);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let (dense_index, sparse_index) = self.inner.next()?;
+        Some((*sparse_index, dense_index as u32))
     }
 }