1 files changed, 273 insertions, 0 deletions
diff --git a/engine-ecs/src/query/term.rs b/engine-ecs/src/query/term.rs
new file mode 100644
index 0000000..453a750
--- /dev/null
+++ b/engine-ecs/src/query/term.rs
@@ -0,0 +1,273 @@
+use std::any::type_name;
+use std::marker::PhantomData;
+
+use crate::component::{
+    Component,
+    Handle as ComponentHandle,
+    HandleMut as ComponentHandleMut,
+};
+use crate::query::{
+    FoundByTraversal,
+    SearchResult,
+    Term,
+    TermMetadata,
+    TermTuple,
+    TermsBuilder,
+    TermsBuilderInterface,
+    Traversal,
+    TraversalKind,
+};
+use crate::uid::With as WithUid;
+use crate::World;
+
+pub struct With<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    _pd: PhantomData<WithUidT>,
+}
+
+impl<'query, WithUidT> Term<'query> for With<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    type Fields = ();
+
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+        _term_metadata: TermMetadata,
+    )
+    {
+        terms_builder.present([WithUidT::uid()]);
+    }
+
+    fn fields(
+        _world: &'query World,
+        _search_result: &SearchResult<'query, '_>,
+        _term_metadata: TermMetadata,
+    ) -> Self::Fields
+    {
+        ()
+    }
+}
+
+pub struct Without<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    _pd: PhantomData<WithUidT>,
+}
+
+impl<'query, WithUidT> Term<'query> for Without<WithUidT>
+where
+    WithUidT: WithUid,
+{
+    type Fields = ();
+
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+        _term_metadata: TermMetadata,
+    )
+    {
+        terms_builder.absent([WithUidT::uid()]);
+    }
+
+    fn fields(
+        _world: &'query World,
+        _search_result: &SearchResult<'query, '_>,
+        _term_metadata: TermMetadata,
+    ) -> Self::Fields
+    {
+        ()
+    }
+}
+
+impl<'query, ComponentT: Component> Term<'query> for Option<&ComponentT>
+{
+    type Fields = (Option<ComponentHandle<'query, ComponentT>>,);
+
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+        _term_metadata: TermMetadata,
+    )
+    {
+    }
+
+    fn fields(
+        _world: &'query World,
+        search_result: &SearchResult<'query, '_>,
+        _term_metadata: TermMetadata,
+    ) -> Self::Fields
+    {
+        let component = (|| {
+            let comp_ref = &search_result
+                .entity_handle
+                .get_matching_components(ComponentT::id())
+                .next()?;
+
+            match ComponentHandle::<ComponentT>::from_entity_component_ref(comp_ref) {
+                Ok(component) => Some(component),
+                Err(err) => {
+                    panic!(
+                        "Creating handle to component {} failed: {err}",
+                        type_name::<ComponentT>()
+                    );
+                }
+            }
+        })();
+
+        (component,)
+    }
+}
+
+impl<'query, ComponentT: Component> Term<'query> for Option<&mut ComponentT>
+{
+    type Fields = (Option<ComponentHandleMut<'query, ComponentT>>,);
+
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+        _term_metadata: TermMetadata,
+    )
+    {
+    }
+
+    fn fields(
+        world: &'query World,
+        search_result: &SearchResult<'query, '_>,
+        _term_metadata: TermMetadata,
+    ) -> Self::Fields
+    {
+        let component = (|| {
+            let comp_ref = &search_result
+                .entity_handle
+                .get_matching_components(ComponentT::id())
+                .next()?;
+
+            match ComponentHandleMut::<ComponentT>::from_entity_component_ref(
+                comp_ref, world,
+            ) {
+                Ok(component) => Some(component),
+                Err(err) => {
+                    panic!(
+                        "Creating mut handle to component {} failed: {err}",
+                        type_name::<ComponentT>()
+                    );
+                }
+            }
+        })();
+
+        (component,)
+    }
+}
+
+pub struct Traverse<TermsT, Kind, Relation>
+{
+    _pd: PhantomData<(TermsT, Kind, Relation)>,
+}
+
+impl<'query, TermsT, Kind, Relation> Term<'query> for Traverse<TermsT, Kind, Relation>
+where
+    TermsT: TermTuple<'query>,
+    Kind: TraversalKindType,
+    Relation: Component,
+{
+    type Fields = TermsT::Fields;
+
+    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
+        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
+        term_metadata: TermMetadata,
+    )
+    {
+        terms_builder.traverse([Traversal {
+            kind: Kind::traversal_kind(),
+            relation: Relation::id(),
+            terms: |traversal| {
+                let mut terms_builder = TermsBuilder::default();
+
+                TermsT::apply_terms_to_builder(
+                    &mut terms_builder,
+                    traversal
+                        .term_metadata
+                        .level
+                        .checked_add(1)
+                        .expect("Too large term level. Would overflow"),
+                );
+
+                terms_builder.build()
+            },
+            term_metadata,
+        }]);
+    }
+
+    fn fields(
+        world: &'query World,
+        search_result: &SearchResult<'query, '_>,
+        term_metadata: TermMetadata,
+    ) -> Self::Fields
+    {
+        let Some(traversal_result) = search_result
+            .traversal_results
+            .iter()
+            .find(|traversal_result| traversal_result.term_metadata == term_metadata)
+        else {
+            unreachable!();
+        };
+
+        let ent = match traversal_result.found {
+            FoundByTraversal::SelfEntity => search_result.entity_handle.clone(),
+            FoundByTraversal::OtherEntity(found_ent_id) => {
+                let Some(found_ent) = world.get_entity(found_ent_id) else {
+                    unreachable!();
+                };
+
+                found_ent
+            }
+        };
+
+        TermsT::get_fields(
+            world,
+            &SearchResult {
+                entity_handle: ent,
+                traversal_results: search_result.traversal_results,
+            },
+            term_metadata
+                .level
+                .checked_add(1)
+                .expect("Too large term level. Would overflow"),
+        )
+    }
+}
+
+pub trait TraversalKindType: sealed::Sealed
+{
+    fn traversal_kind() -> TraversalKind;
+}
+
+pub struct TraverseUp;
+
+impl TraversalKindType for TraverseUp
+{
+    fn traversal_kind() -> TraversalKind
+    {
+        TraversalKind::Up
+    }
+}
+
+impl sealed::Sealed for TraverseUp {}
+
+pub struct TraverseSelfOrUp;
+
+impl TraversalKindType for TraverseSelfOrUp
+{
+    fn traversal_kind() -> TraversalKind
+    {
+        TraversalKind::SelfOrUp
+    }
+}
+
+impl sealed::Sealed for TraverseSelfOrUp {}
+
+mod sealed
+{
+    pub trait Sealed {}
+}