wip: transitioning to the newer comet_structs and new ComponentStorage through a FlatMap (not the rust implementation)

crates/comet_structs/src/component_storage.rs

@@ -0,0 +1,74 @@
+use std::any::{Any, TypeId};
+use comet_log::*;
+use crate::{FlatMap, IterMut, SparseSet};
+
+pub type ComponentStorage = FlatMap<TypeId, SparseSet>;
+
+impl ComponentStorage {
+
+	pub fn register_component<T: 'static>(&mut self, capacity: usize) {
+		if !self.contains(&TypeId::of::<T>()) {
+			self.insert(TypeId::of::<T>(), SparseSet::new::<T>(capacity));
+			info!("Component {:?} has been registered", TypeId::of::<T>());
+		}
+		else {
+			error!("Component {:?} already exists", TypeId::of::<T>());
+		}
+	}
+
+	pub fn deregister_component<T: 'static>(&mut self) {
+		if self.contains(&TypeId::of::<T>()) {
+			self.remove(&TypeId::of::<T>());
+			info!("Component {:?} has been deregistered", TypeId::of::<T>());
+		}
+		else {
+			error!("Component {:?} does not exist", TypeId::of::<T>());
+		}
+	}
+
+	pub fn set_component<T: 'static>(&mut self, index: usize, element: T) {
+		if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
+			sparse_set.set(index, element);
+		}
+		else {
+			error!("Component {:?} is not registered", TypeId::of::<T>());
+		}
+	}
+
+	pub fn remove_component<T: 'static>(&mut self, index: usize) -> Option<T> {
+		if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
+			sparse_set.remove(index)
+		}
+		else {
+			error!("Component {:?} is not registered", TypeId::of::<T>());
+			None
+		}
+	}
+
+	pub fn get_component<T: 'static>(&self, index: usize) -> Option<&T> {
+		if let Some(sparse_set) = self.get(&TypeId::of::<T>()) {
+			sparse_set.get(index)
+		}
+		else {
+			error!("Component {:?} is not registered", TypeId::of::<T>());
+			None
+		}
+	}
+
+	pub fn get_component_mut<T: 'static>(&mut self, index: usize) -> Option<&mut T> {
+		if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
+			sparse_set.get_mut(index)
+		}
+		else {
+			error!("Component {:?} is not registered", TypeId::of::<T>());
+			None
+		}
+	}
+
+	pub fn iter_mut(&mut self) -> IterMut<'_, &TypeId, &SparseSet> {
+		IterMut {
+			keys_iter: self.keys_mut(),
+			values_iter: self.values_mut(),
+		}
+	}
+}

crates/comet_structs/src/flat_map.rs

@@ -1,64 +1,83 @@
+#[derive(Clone)]
 pub struct MapNode<K, V> {
-  key: K,
-  value: V
+    key: K,
+    value: V
 }
 
 impl<K, V> MapNode<K,V> {
-  pub fn new(key: K, value: V) -> Self {
-    Self {
-      key,
-      value
+    pub fn new(key: K, value: V) -> Self {
+        Self {
+            key,
+            value
+        }
     }
-  }
 
-  pub fn key(&self) -> &K {
-    &self.key
-  }
+    pub fn key(&self) -> &K {
+        &self.key
+    }
 
-  pub fn value(&self) -> &V {
-    &self.value
-  }
+    pub fn value(&self) -> &V {
+        &self.value
+    }
 }
 
+#[derive(Clone)]
 pub struct FlatMap<K: PartialEq, V> {
-  map: Vec<MapNode<K, V>>
+    map: Vec<MapNode<K, V>>
 }
 
 impl<K: PartialEq, V> FlatMap<K, V> {
-  pub fn new() -> Self {
-    Self {
-      map: Vec::new()
+    pub fn new() -> Self {
+        Self {
+            map: Vec::new()
+        }
     }
-  }
 
-  pub fn insert(&mut self, key: K, value: V) {
-    let node = MapNode::new(key, value);
-    self.map.push(node);
-  }
-
-  pub fn remove(&mut self, key: K) {
-    for node in self.map {
-      if node.key() == *key {
-        self.map.retain(|&n| n.key() != *key);
-      }
+    pub fn keys(&self) -> Vec<&K> {
+        self.map.iter().map(|node| node.key()).collect::<Vec<&K>>()
     }
-  }
 
-  pub fn get(&self, key: K) -> Option<&V> {
-    for node in self.map {
-      if node.key() == *key {
-        return Some(&node.value);
-      }
+    pub fn values(&self) -> Vec<&V> {
+        self.map.iter().map(|node| node.value()).collect::<Vec<&V>>()
     }
-    None
-  }
 
-  pub fn get_mut(&mut self, key: K) -> Option<&mut V> {
-    for mut node in self.map {
-      if node.key() == *key {
-        return Some(node.value);
-      }
+    pub fn keys_mut(&mut self) -> impl Iterator<Item = &mut K> {
+        self.map.iter_mut().map(|node| &mut node.key)
+    }
+
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
+        self.map.iter_mut().map(|node| &mut node.value)
+    }
+
+    pub fn insert(&mut self, key: K, value: V) {
+        let node = MapNode::new(key, value);
+        self.map.push(node);
+    }
+
+    pub fn remove(&mut self, key: &K) {
+        self.map.retain(|node| node.key() != key);
+    }
+
+    pub fn get(&self, key: &K) -> Option<&V> {
+        self.map.iter()
+            .find(|node| node.key() == key)
+            .map(|node| node.value())
+    }
+
+    pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
+        self.map.iter_mut()
+            .find(|node| node.key() == key)
+            .map(|node| node.value_mut())
+    }
+
+    pub fn contains(&self, key: &K) -> bool {
+        self.map.iter().any(|node| node.key() == key)
     }
-    None
-  }
 }
+
+// Add this method to MapNode to allow mutable access to value
+impl<K, V> MapNode<K, V> {
+    fn value_mut(&mut self) -> &mut V {
+        &mut self.value
+    }
+}

crates/comet_structs/src/iter_mut.rs

@@ -0,0 +1,15 @@
+pub struct IterMut<'a, K, V> {
+	pub(crate) keys_iter: std::slice::IterMut<'a, K>,
+	pub(crate) values_iter: std::slice::IterMut<'a, V>,
+}
+
+impl<'a, K, V> Iterator for IterMut<'a, K, V> {
+	type Item = (&'a mut K, &'a mut V);
+
+	fn next(&mut self) -> Option<Self::Item> {
+		match (self.keys_iter.next(), self.values_iter.next()) {
+			(Some(key), Some(value)) => Some((key, value)),
+			_ => None,
+		}
+	}
+}

crates/comet_structs/src/lib.rs

@@ -1,7 +1,11 @@
 pub use column::Column;
 pub use sparse_set::SparseSet;
 pub use flat_map::FlatMap;
+pub use component_storage::ComponentStorage;
+pub use iter_mut::IterMut;
 
 mod column;
 mod sparse_set;
-mod flat_map;
+mod flat_map;
+mod component_storage;
+mod iter_mut;