Various utility fns around Entity/Component

src/component.rs

···
         Ok(rusqlite::types::Value::Null)
     }
 }
+
+pub trait ComponentSet {
+    const SIZE: usize;
+    type Array<T>: From<Self::Tuple<T>> + IntoIterator<Item = T> + AsRef<[T]> + TryFrom<Vec<T>>;
+    type Tuple<T>: From<Self::Array<T>>;
+
+    fn component_names() -> Self::Array<&'static str>;
+}
+
+macro_rules! type_as_other {
+    ( $a: ty, $b: ty ) => {
+        $b
+    };
+}
+
+macro_rules! impl_component_set {
+    ($s: literal, $($c: ident),*) => {
+        impl<$($c: Component),*> ComponentSet for ($($c,)*)
+        {
+            const SIZE: usize = $s;
+            type Array<T> = [T; $s];
+            type Tuple<T> = ($(type_as_other!($c, T),)*);
+
+            fn component_names() -> Self::Array<&'static str> {
+                [
+                    $($c::component_name()),*
+                ]
+            }
+        }
+    }}
+
+impl_component_set!(1, C1);
+impl_component_set!(2, C1, C2);
+impl_component_set!(3, C1, C2, C3);
+impl_component_set!(4, C1, C2, C3, C4);
+impl_component_set!(5, C1, C2, C3, C4, C5);
+impl_component_set!(6, C1, C2, C3, C4, C5, C6);

src/entity.rs

···
-use std::iter;
+use std::{fmt::write, iter};
 
-use rusqlite::params;
+use rusqlite::{params, OptionalExtension};
+use serde::{de::DeserializeOwned, Deserialize};
 use tracing::debug;
 
-use crate::{BelongsTo, Component, ComponentWrite, Ecs, EntityId, Error};
+use crate::{component::ComponentSet, BelongsTo, Component, ComponentWrite, Ecs, EntityId, Error};
 
 #[derive(Debug, Copy, Clone)]
 pub struct WithoutEntityId;
···
         self.0
     }
 
+    pub fn has<T: Component>(&self) -> bool {
+        self.try_has::<T>().unwrap()
+    }
+
+    pub fn try_has<T: Component>(&self) -> Result<bool, Error> {
+        self.has_dynamic(T::component_name())
+    }
+
+    pub fn has_many<C: ComponentSet>(&self) -> C::Array<bool> {
+        let names = C::component_names();
+        let names = names
+            .into_iter()
+            .map(|name| self.has_dynamic(&name).unwrap())
+            .collect::<Vec<_>>();
+        C::Array::try_from(names).map_err(|_| ()).unwrap()
+    }
+
+    fn has_dynamic(&self, name: &str) -> Result<bool, Error> {
+        let row = self
+            .0
+            .conn
+            .query_row(
+                "select true from components where entity = ?1 and component = ?2",
+                params![self.id(), name],
+                |_| Ok(()),
+            )
+            .optional()?;
+        Ok(row.is_some())
+    }
+
     pub fn component<T: Component>(&self) -> Option<T> {
         self.try_component::<T>().unwrap()
     }
···
         self.try_destroy().unwrap();
     }
 
+    pub fn component_names(&self) -> impl Iterator<Item = String> {
+        self.try_component_names().unwrap()
+    }
+
     #[tracing::instrument(name = "attach", level = "debug", skip_all)]
     pub fn try_attach<T: Component>(self, component: T) -> Result<Self, Error> {
         let data = T::to_rusqlite(component)?;
···
         debug!(entity = self.id(), "destroyed");
         Ok(())
     }
+
+    #[tracing::instrument(name = "component_names", level = "debug")]
+    pub fn try_component_names(&self) -> Result<impl Iterator<Item = String>, Error> {
+        let mut stmt = self
+            .0
+            .conn
+            .prepare("select component from components where entity = ?1")?;
+        let names = stmt
+            .query_map(params![self.id()], |row| row.get(0))?
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(names.into_iter())
+    }
 }
 
 impl<'a> NewEntity<'a> {
···
         self
     }
 
+    pub fn component_names(&self) -> impl Iterator<Item = String> {
+        std::iter::empty()
+    }
+
     #[tracing::instrument(name = "attach", level = "debug", skip_all)]
     pub fn try_attach<T: Component + ComponentWrite<T>>(
         self,
···
     #[tracing::instrument(name = "detach", level = "debug", skip_all)]
     pub fn try_detach<T: Component>(&mut self) -> Result<&mut Self, Error> {
         Ok(self)
+    }
+
+    #[tracing::instrument(name = "component_names", level = "debug")]
+    pub fn try_component_names(&self) -> Result<impl Iterator<Item = String>, Error> {
+        Ok(std::iter::empty())
     }
 }