refactor(engine): replace MapVec with intmap crate

1 files changed, 1 insertions, 134 deletions

diff --git a/engine/src/util.rs b/engine/src/util.rs
index e845340..a7caa2a 100644
--- a/engine/src/util.rs
+++ b/engine/src/util.rs
@@ -1,139 +1,6 @@
 use std::fmt::{Debug, Display};
 
-use crate::ecs::util::{StreamingIterator, VecExt};
-
-#[derive(Debug, Clone)]
-pub struct MapVec<Key: Ord, Value>
-{
-    inner: Vec<(Key, Value)>,
-}
-
-impl<Key: Ord, Value> MapVec<Key, Value>
-{
-    pub fn with_capacity(capacity: usize) -> Self
-    {
-        Self { inner: Vec::with_capacity(capacity) }
-    }
-
-    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 insert_mut(&mut self, key: Key, value: Value) -> &mut Value
-    {
-        let insert_index = self
-            .inner
-            .partition_point(|(other_key, _other_value)| other_key <= &key);
-
-        &mut self.inner.insert_mut(insert_index, (key, value)).1
-    }
-
-    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 entry(&mut self, key: Key) -> MapVecEntry<'_, Key, Value>
-    {
-        let index = self
-            .inner
-            .binary_search_by_key(&&key, |(a_key, _)| a_key)
-            .ok();
-
-        MapVecEntry { map: self, key, index }
-    }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&mut Key, &mut Value)>
-    {
-        self.inner.iter_mut().map(|(key, value)| (key, value))
-    }
-
-    pub fn values(&self) -> impl Iterator<Item = &Value>
-    {
-        self.inner.iter().map(|(_, value)| value)
-    }
-}
-
-impl<Key: Ord, Value> FromIterator<(Key, Value)> for MapVec<Key, Value>
-{
-    fn from_iter<Iter: IntoIterator<Item = (Key, Value)>>(iter: Iter) -> Self
-    {
-        let mut items = iter.into_iter().collect::<Vec<_>>();
-
-        if !items.is_sorted_by_key(|(key, _)| key) {
-            items.sort_by(|(key_a, _), (key_b, _)| key_a.cmp(key_b));
-        }
-
-        Self { inner: items }
-    }
-}
-
-impl<Key: Ord, Value> Default for MapVec<Key, Value>
-{
-    fn default() -> Self
-    {
-        Self { inner: Vec::new() }
-    }
-}
-
-pub struct MapVecEntry<'map, Key: Ord, Value>
-{
-    map: &'map mut MapVec<Key, Value>,
-    key: Key,
-    index: Option<usize>,
-}
-
-impl<'map, Key: Ord, Value> MapVecEntry<'map, Key, Value>
-{
-    pub fn or_insert_with(self, func: impl FnOnce() -> Value) -> &'map mut Value
-    {
-        match self.index {
-            Some(index) => {
-                let (_, value) = unsafe { self.map.inner.get_unchecked_mut(index) };
-
-                value
-            }
-            None => self.map.insert_mut(self.key, func()),
-        }
-    }
-}
+use crate::ecs::util::StreamingIterator;
 
 pub trait OptionExt<T>
 {