3 files changed, 199 insertions, 66 deletions
diff --git a/ecs/src/query/flexible.rs b/ecs/src/query/flexible.rs
new file mode 100644
index 0000000..add30b0
--- /dev/null
+++ b/ecs/src/query/flexible.rs
@@ -0,0 +1,84 @@
+//! Low-level querying.
+use std::iter::{repeat_n, FlatMap, RepeatN, Zip};
+
+use crate::component::storage::archetype::{Archetype, EntityIter};
+use crate::component::storage::{ArchetypeRefIter, ArchetypeSearchTerms};
+use crate::entity::Handle as EntityHandle;
+use crate::query::Terms;
+use crate::World;
+
+/// Low-level entity query structure.
+#[derive(Debug)]
+pub struct Query<'world, const MAX_TERM_CNT: usize>
+{
+    world: &'world World,
+    terms: Terms<MAX_TERM_CNT>,
+}
+
+impl<'world, const MAX_TERM_CNT: usize> Query<'world, MAX_TERM_CNT>
+{
+    /// Iterates over the entities matching this query.
+    #[must_use]
+    pub fn iter(&self) -> Iter<'_>
+    {
+        Iter {
+            iter: self
+                .world
+                .data
+                .component_storage
+                .search_archetypes(ArchetypeSearchTerms {
+                    required_components: &self.terms.required_components,
+                    excluded_components: &self.terms.excluded_components,
+                })
+                .flat_map(
+                    (|archetype| {
+                        repeat_n(archetype, archetype.entity_cnt())
+                            .zip(archetype.entities())
+                    }) as ComponentIterMapFn,
+                ),
+        }
+    }
+
+    pub(crate) fn new(world: &'world World, terms: Terms<MAX_TERM_CNT>) -> Self
+    {
+        Self { world, terms }
+    }
+}
+
+impl<'query, const MAX_TERM_CNT: usize> IntoIterator for &'query Query<'_, MAX_TERM_CNT>
+{
+    type IntoIter = Iter<'query>;
+    type Item = EntityHandle<'query>;
+
+    fn into_iter(self) -> Self::IntoIter
+    {
+        self.iter()
+    }
+}
+
+pub struct Iter<'query>
+{
+    iter: QueryEntityIter<'query>,
+}
+
+impl<'query> Iterator for Iter<'query>
+{
+    type Item = EntityHandle<'query>;
+
+    fn next(&mut self) -> Option<Self::Item>
+    {
+        let (archetype, entity) = self.iter.next()?;
+
+        Some(EntityHandle::new(archetype, entity))
+    }
+}
+
+type ComponentIterMapFnOutput<'a> = Zip<RepeatN<&'a Archetype>, EntityIter<'a>>;
+
+type ComponentIterMapFn = for<'a> fn(&'a Archetype) -> ComponentIterMapFnOutput<'a>;
+
+type QueryEntityIter<'query> = FlatMap<
+    ArchetypeRefIter<'query, 'query>,
+    ComponentIterMapFnOutput<'query>,
+    ComponentIterMapFn,
+>;
diff --git a/ecs/src/query/options.rs b/ecs/src/query/options.rs
deleted file mode 100644
index bbbe0a8..0000000
--- a/ecs/src/query/options.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use std::collections::HashSet;
-use std::marker::PhantomData;
-
-use crate::component::Component;
-use crate::EntityComponent;
-
-/// Query options.
-pub trait Options
-{
-    fn entity_filter<'component>(
-        components: impl IntoIterator<Item = &'component EntityComponent>,
-    ) -> bool;
-}
-
-impl Options for ()
-{
-    fn entity_filter<'component>(
-        _: impl IntoIterator<Item = &'component EntityComponent>,
-    ) -> bool
-    {
-        true
-    }
-}
-
-pub struct With<ComponentT>
-where
-    ComponentT: Component,
-{
-    _pd: PhantomData<ComponentT>,
-}
-
-impl<ComponentT> Options for With<ComponentT>
-where
-    ComponentT: Component,
-{
-    fn entity_filter<'component>(
-        components: impl IntoIterator<Item = &'component EntityComponent>,
-    ) -> bool
-    {
-        let ids_set = components
-            .into_iter()
-            .map(|component| component.id)
-            .collect::<HashSet<_>>();
-
-        ids_set.contains(&ComponentT::id())
-    }
-}
-
-pub struct Not<OptionsT>
-where
-    OptionsT: Options,
-{
-    _pd: PhantomData<OptionsT>,
-}
-
-impl<OptionsT> Options for Not<OptionsT>
-where
-    OptionsT: Options,
-{
-    fn entity_filter<'component>(
-        components: impl IntoIterator<Item = &'component EntityComponent>,
-    ) -> bool
-    {
-        !OptionsT::entity_filter(components)
-    }
-}
diff --git a/ecs/src/query/term.rs b/ecs/src/query/term.rs
new file mode 100644
index 0000000..9c772da
--- /dev/null
+++ b/ecs/src/query/term.rs
@@ -0,0 +1,115 @@
+use std::any::type_name;
+use std::marker::PhantomData;
+
+use crate::component::{
+    Component,
+    Handle as ComponentHandle,
+    HandleMut as ComponentHandleMut,
+};
+use crate::query::{
+    TermWithField,
+    TermWithoutField,
+    TermsBuilder,
+    TermsBuilderInterface,
+};
+use crate::uid::With as WithUid;
+
+pub struct With<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    _pd: PhantomData<WithUidT>,
+}
+
+impl<WithUidT> TermWithoutField for With<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+    )
+    {
+        terms_builder.with::<WithUidT>();
+    }
+}
+
+pub struct Without<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    _pd: PhantomData<WithUidT>,
+}
+
+impl<WithUidT> TermWithoutField for Without<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+    )
+    {
+        terms_builder.without::<WithUidT>();
+    }
+}
+
+impl<ComponentT: Component> TermWithField for Option<&ComponentT>
+{
+    type Field<'a> = Option<ComponentHandle<'a, ComponentT>>;
+
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+    )
+    {
+    }
+
+    fn get_field<'world>(
+        entity_handle: &crate::entity::Handle<'world>,
+        _world: &'world crate::World,
+    ) -> Self::Field<'world>
+    {
+        Some(
+            ComponentHandle::<'world, ComponentT>::from_entity_component_ref(
+                entity_handle
+                    .get_matching_components(ComponentT::id())
+                    .next()?,
+            )
+            .unwrap_or_else(|err| {
+                panic!(
+                    "Creating handle to component {} failed: {err}",
+                    type_name::<ComponentT>()
+                );
+            }),
+        )
+    }
+}
+
+impl<ComponentT: Component> TermWithField for Option<&mut ComponentT>
+{
+    type Field<'a> = Option<ComponentHandleMut<'a, ComponentT>>;
+
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+    )
+    {
+    }
+
+    fn get_field<'world>(
+        entity_handle: &crate::entity::Handle<'world>,
+        _world: &'world crate::World,
+    ) -> Self::Field<'world>
+    {
+        Some(
+            ComponentHandleMut::<'world, ComponentT>::from_entity_component_ref(
+                entity_handle
+                    .get_matching_components(ComponentT::id())
+                    .next()?,
+            )
+            .unwrap_or_else(|err| {
+                panic!(
+                    "Creating handle to component {} failed: {err}",
+                    type_name::<ComponentT>()
+                );
+            }),
+        )
+    }
+}