[Merged by Bors] - Immutable sparse sets for metadata storage

crates/bevy_ecs/src/storage/sparse_set.rs

@@ -89,6 +89,33 @@ impl<I: SparseSetIndex, V> SparseArray<I, V> {
     pub fn clear(&mut self) {
         self.values.clear();
     }
+
+    pub fn to_immutable(self) -> ImmutableSparseArray<I, V> {
+        ImmutableSparseArray {
+            values: self.values.into_boxed_slice(),
+            marker: PhantomData,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ImmutableSparseArray<I, V = I> {
+    values: Box<[Option<V>]>,
+    marker: PhantomData<I>,
+}
+
+impl<I: SparseSetIndex, V> ImmutableSparseArray<I, V> {
+    #[inline]
+    pub fn contains(&self, index: I) -> bool {
+        let index = index.sparse_set_index();
+        self.values.get(index).map(|v| v.is_some()).unwrap_or(false)
+    }
+
+    #[inline]
+    pub fn get(&self, index: I) -> Option<&V> {
+        let index = index.sparse_set_index();
+        self.values.get(index).map(|v| v.as_ref()).unwrap_or(None)
+    }
 }
 
 /// A sparse data structure of [Components](crate::component::Component)
@@ -426,6 +453,73 @@ impl<I: SparseSetIndex, V> SparseSet<I, V> {
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (&I, &mut V)> {
         self.indices.iter().zip(self.dense.iter_mut())
     }
+
+    pub fn to_immutable(self) -> ImmutableSparseSet<I, V> {
+        ImmutableSparseSet {
+            dense: self.dense.into_boxed_slice(),
+            indices: self.indices.into_boxed_slice(),
+            sparse: self.sparse.to_immutable(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ImmutableSparseSet<I, V: 'static> {
+    dense: Box<[V]>,
+    indices: Box<[I]>,
+    sparse: ImmutableSparseArray<I, usize>,
+}
+
+impl<I: SparseSetIndex, V> ImmutableSparseSet<I, V> {
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.dense.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.dense.len() == 0
+    }
+
+    #[inline]
+    pub fn contains(&self, index: I) -> bool {
+        self.sparse.contains(index)
+    }
+
+    pub fn get(&self, index: I) -> Option<&V> {
+        self.sparse.get(index).map(|dense_index| {
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            unsafe { self.dense.get_unchecked(*dense_index) }
+        })
+    }
+
+    pub fn get_mut(&mut self, index: I) -> Option<&mut V> {
+        let dense = &mut self.dense;
+        self.sparse.get(index).map(move |dense_index| {
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            unsafe { dense.get_unchecked_mut(*dense_index) }
+        })
+    }
+
+    pub fn indices(&self) -> impl Iterator<Item = I> + '_ {
+        self.indices.iter().cloned()
+    }
+
+    pub fn values(&self) -> impl Iterator<Item = &V> {
+        self.dense.iter()
+    }
+
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
+        self.dense.iter_mut()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&I, &V)> {
+        self.indices.iter().zip(self.dense.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&I, &mut V)> {
+        self.indices.iter().zip(self.dense.iter_mut())
+    }
 }
 
 pub trait SparseSetIndex: Clone + PartialEq + Eq + Hash {

crates/bevy_ecs/src/storage/table.rs

@@ -1,7 +1,7 @@
 use crate::{
     component::{ComponentId, ComponentInfo, ComponentTicks, Components},
     entity::Entity,
-    storage::{BlobVec, SparseSet},
+    storage::{BlobVec, ImmutableSparseSet, SparseSet},
 };
 use bevy_ptr::{OwningPtr, Ptr, PtrMut};
 use bevy_utils::HashMap;
@@ -186,38 +186,45 @@ impl Column {
     }
 }
 
-pub struct Table {
+pub struct TableBuilder {
     columns: SparseSet<ComponentId, Column>,
-    entities: Vec<Entity>,
+    capacity: usize,
 }
 
-impl Table {
-    pub const fn new() -> Table {
+impl TableBuilder {
+    pub fn with_capacity(capacity: usize, column_capacity: usize) -> Self {
         Self {
-            columns: SparseSet::new(),
-            entities: Vec::new(),
+            columns: SparseSet::with_capacity(column_capacity),
+            capacity,
         }
     }
 
-    pub fn with_capacity(capacity: usize, column_capacity: usize) -> Table {
-        Self {
-            columns: SparseSet::with_capacity(column_capacity),
-            entities: Vec::with_capacity(capacity),
+    pub fn add_column(&mut self, component_info: &ComponentInfo) {
+        self.columns.insert(
+            component_info.id(),
+            Column::with_capacity(component_info, self.capacity),
+        );
+    }
+
+    pub fn build(self) -> Table {
+        Table {
+            columns: self.columns.to_immutable(),
+            entities: Vec::with_capacity(self.capacity),
         }
     }
+}
+
+pub struct Table {
+    columns: ImmutableSparseSet<ComponentId, Column>,
+    entities: Vec<Entity>,
+}
 
+impl Table {
     #[inline]
     pub fn entities(&self) -> &[Entity] {
         &self.entities
     }
 
-    pub fn add_column(&mut self, component_info: &ComponentInfo) {
-        self.columns.insert(
-            component_info.id(),
-            Column::with_capacity(component_info, self.entities.capacity()),
-        );
-    }
-
     /// Removes the entity at the given row and returns the entity swapped in to replace it (if an
     /// entity was swapped in)
     ///
@@ -414,7 +421,7 @@ pub struct Tables {
 
 impl Default for Tables {
     fn default() -> Self {
-        let empty_table = Table::with_capacity(0, 0);
+        let empty_table = TableBuilder::with_capacity(0, 0).build();
         Tables {
             tables: vec![empty_table],
             table_ids: HashMap::default(),
@@ -472,11 +479,11 @@ impl Tables {
             .raw_entry_mut()
             .from_key(component_ids)
             .or_insert_with(|| {
-                let mut table = Table::with_capacity(0, component_ids.len());
+                let mut table = TableBuilder::with_capacity(0, component_ids.len());
                 for component_id in component_ids.iter() {
                     table.add_column(components.get_info_unchecked(*component_id));
                 }
-                tables.push(table);
+                tables.push(table.build());
                 (component_ids.to_vec(), TableId(tables.len() - 1))
             });
 
@@ -526,7 +533,7 @@ mod tests {
     use crate::component::Component;
     use crate::ptr::OwningPtr;
     use crate::storage::Storages;
-    use crate::{component::Components, entity::Entity, storage::Table};
+    use crate::{component::Components, entity::Entity, storage::TableBuilder};
     #[derive(Component)]
     struct W<T>(T);
 
@@ -536,8 +543,9 @@ mod tests {
         let mut storages = Storages::default();
         let component_id = components.init_component::<W<usize>>(&mut storages);
         let columns = &[component_id];
-        let mut table = Table::with_capacity(0, columns.len());
-        table.add_column(components.get_info(component_id).unwrap());
+        let mut builder = TableBuilder::with_capacity(0, columns.len());
+        builder.add_column(components.get_info(component_id).unwrap());
+        let mut table = builder.build();
         let entities = (0..200).map(Entity::from_raw).collect::<Vec<_>>();
         for entity in &entities {
             // SAFE: we allocate and immediately set data afterwards