1 files changed, 97 insertions, 83 deletions

diff --git a/engine/src/util.rs b/engine/src/util.rs
index 0f6c78c..9174734 100644
--- a/engine/src/util.rs
+++ b/engine/src/util.rs
@@ -1,4 +1,72 @@
-use std::marker::PhantomData;
+use ecs::util::VecExt;
+
+#[derive(Debug)]
+pub struct MapVec<Key: Ord, Value>
+{
+    inner: Vec<(Key, Value)>,
+}
+
+impl<Key: Ord, Value> MapVec<Key, Value>
+{
+    pub fn insert(&mut self, key: Key, value: Value)
+    {
+        self.inner
+            .insert_at_part_pt_by_key((key, value), |(a_key, _)| a_key);
+    }
+
+    pub fn remove(&mut self, key: Key) -> Option<Value>
+    {
+        let index = self
+            .inner
+            .binary_search_by_key(&&key, |(a_key, _)| a_key)
+            .ok()?;
+
+        let (_, value) = self.inner.remove(index);
+
+        Some(value)
+    }
+
+    pub fn get(&self, key: &Key) -> Option<&Value>
+    {
+        let index = self
+            .inner
+            .binary_search_by_key(&key, |(a_key, _)| a_key)
+            .ok()?;
+
+        let Some((_, value)) = self.inner.get(index) else {
+            unreachable!(); // Reason: Index from binary search cannot be OOB
+        };
+
+        Some(value)
+    }
+
+    pub fn get_mut(&mut self, key: &Key) -> Option<&mut Value>
+    {
+        let index = self
+            .inner
+            .binary_search_by_key(&key, |(a_key, _)| a_key)
+            .ok()?;
+
+        let Some((_, value)) = self.inner.get_mut(index) else {
+            unreachable!(); // Reason: Index from binary search cannot be OOB
+        };
+
+        Some(value)
+    }
+
+    pub fn values(&self) -> impl Iterator<Item = &Value>
+    {
+        self.inner.iter().map(|(_, value)| value)
+    }
+}
+
+impl<Key: Ord, Value> Default for MapVec<Key, Value>
+{
+    fn default() -> Self
+    {
+        Self { inner: Vec::new() }
+    }
+}
 
 macro_rules! try_option {
     ($expr: expr) => {
@@ -25,6 +93,18 @@ macro_rules! or {
 
 pub(crate) use or;
 
+#[macro_export]
+macro_rules! expand_map_opt {
+    ($in: tt, no_occurance=($($no_occurance: tt)*), occurance=($($occurance: tt)*)) => {
+        $($occurance)*
+    };
+
+    (, no_occurance=($($no_occurance: tt)*), occurance=($($occurance: tt)*)) => {
+        $($no_occurance)*
+    };
+}
+
+#[macro_export]
 macro_rules! builder {
     (
         $(#[doc = $doc: literal])*
@@ -36,7 +116,8 @@ macro_rules! builder {
         $visibility: vis struct $name: ident
         {
             $(
-                $(#[$field_attr: meta])*
+                $(#[doc = $field_doc: literal])*
+                $(#[builder(skip_generate_fn$($field_skip_generate_fn: tt)?)])?
                 $field_visibility: vis $field: ident: $field_type: ty,
             )*
         }
@@ -46,7 +127,7 @@ macro_rules! builder {
         $visibility struct $name
         {
             $(
-                $(#[$field_attr])*
+                $(#[doc = $field_doc])*
                 $field_visibility $field: $field_type,
             )*
         }
@@ -62,12 +143,18 @@ macro_rules! builder {
         impl $builder_name
         {
             $(
-                #[must_use]
-                $visibility fn $field(mut self, $field: $field_type) -> Self
-                {
-                    self.$field = $field;
-                    self
-                }
+                $crate::expand_map_opt!(
+                    $(true $($field_skip_generate_fn)?)?,
+                    no_occurance=(
+                        #[must_use]
+                        $visibility fn $field(mut self, $field: $field_type) -> Self
+                        {
+                            self.$field = $field;
+                            self
+                        }
+                    ),
+                    occurance=()
+                );
             )*
 
             #[must_use]
@@ -82,6 +169,7 @@ macro_rules! builder {
 
         impl From<$name> for $builder_name
         {
+            #[allow(unused_variables)]
             fn from(built: $name) -> Self
             {
                 Self {
@@ -93,77 +181,3 @@ macro_rules! builder {
         }
     };
 }
-
-pub(crate) use builder;
-
-pub enum RefOrValue<'a, T>
-{
-    Ref(&'a T),
-    Value(Option<T>),
-}
-
-impl<'a, T> RefOrValue<'a, T>
-{
-    pub fn get(&self) -> Option<&T>
-    {
-        match self {
-            Self::Ref(val_ref) => Some(val_ref),
-            Self::Value(val_cell) => val_cell.as_ref(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Defer<'func, Func, Data>
-where
-    Func: FnMut(&mut Data) + 'func,
-{
-    func: Func,
-    pub data: Data,
-    _pd: PhantomData<&'func ()>,
-}
-
-impl<'func, Func, Data> Defer<'func, Func, Data>
-where
-    Func: FnMut(&mut Data) + 'func,
-{
-    pub fn new(data: Data, func: Func) -> Self
-    {
-        Self { func, data, _pd: PhantomData }
-    }
-}
-
-impl<'func, Func, Data> Drop for Defer<'func, Func, Data>
-where
-    Func: FnMut(&mut Data) + 'func,
-{
-    fn drop(&mut self)
-    {
-        (self.func)(&mut self.data)
-    }
-}
-
-/// Defines a function that will be called at the end of the current scope.
-///
-/// Only captured variables that are later mutably borrowed needs to specified as
-/// captures.
-macro_rules! defer {
-    (|$capture: ident| {$($tt: tt)*}) => {
-        // This uses the automatic temporary lifetime extension behaviour introduced
-        // in Rust 1.79.0 (https://blog.rust-lang.org/2024/06/13/Rust-1.79.0.html) to
-        // create a unnamable variable for the Defer struct. The variable should be
-        // unnamable so that it cannot be missused and so that this macro can be used
-        // multiple times without having to give it a identifier for the Defer struct
-        // variable
-        let Defer { data: $capture, .. } = if true {
-            &Defer::new($capture, |$capture| {
-                $($tt)*
-            })
-        }
-        else {
-            unreachable!();
-        };
-    };
-}
-
-pub(crate) use defer;