initial mask impl

src/util/arena.rs

@@ -0,0 +1,109 @@
+use std::ops::Deref;
+
+use crate::util::{Id, IdNum, IdTracker};
+
+pub struct Arena<T, I> {
+    data: Vec<T>,
+    tracker: IdTracker<I>,
+}
+
+impl<T, I: IdNum> Arena<T, I> {
+    pub fn new() -> Self {
+        Self {
+            data: Vec::new(),
+            tracker: IdTracker::default(),
+        }
+    }
+
+    pub fn push(&mut self, value: T) -> Id<I> {
+        let id = self.tracker.next();
+        let i = id.idx();
+        if i == self.data.len() {
+            self.data.push(value);
+        } else {
+            self.data[i] = value;
+        }
+        id
+    }
+
+    pub fn remove(&mut self, id: Id<I>) -> T
+    where
+        T: Copy,
+    {
+        let i = id.idx();
+        self.tracker.free(id);
+        self.data[i]
+    }
+}
+
+impl<T, I: IdNum> Default for Arena<T, I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct TrackedArena<T, I> {
+    inner: Arena<T, I>,
+    refs: Vec<u32>,
+    pub changed: bool,
+}
+
+impl<T, I: IdNum> TrackedArena<T, I> {
+    pub fn new() -> Self {
+        Self {
+            inner: Arena::default(),
+            refs: Vec::new(),
+            changed: true,
+        }
+    }
+
+    pub fn push(&mut self, value: T) -> Id<I> {
+        self.changed = true;
+        let id = self.inner.push(value);
+        let i = id.idx();
+        if i == self.refs.len() {
+            self.refs.push(0);
+        }
+        id
+    }
+
+    pub fn push_ref(&mut self, i: Id<I>) {
+        self.refs[i.idx()] += 1;
+    }
+
+    pub fn remove(&mut self, id: Id<I>) -> T
+    where
+        T: Copy,
+    {
+        let i = id.idx();
+        self.refs[i] -= 1;
+        if self.refs[i] == 0 {
+            self.changed = true;
+            self.inner.remove(id)
+        } else {
+            self[i]
+        }
+    }
+}
+
+impl<T, I: IdNum> Default for TrackedArena<T, I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T, I> Deref for TrackedArena<T, I> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner.data
+    }
+}
+
+impl<T, I> Deref for Arena<T, I> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}

src/util/id.rs

@@ -1,25 +1,81 @@
-#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy)]
-pub struct Id(u64);
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy, bytemuck::Zeroable)]
+pub struct Id<I = u64>(I);
 
-#[derive(Default)]
-pub struct IdTracker {
-    free: Vec<Id>,
-    cur: u64,
+unsafe impl<I: Copy + bytemuck::Zeroable + 'static> bytemuck::Pod for Id<I> {}
+
+pub struct IdTracker<I = u64> {
+    free: Vec<Id<I>>,
+    cur: Id<I>,
 }
 
-impl IdTracker {
+impl<I: IdNum> IdTracker<I> {
     #[allow(clippy::should_implement_trait)]
-    pub fn next(&mut self) -> Id {
+    pub fn next(&mut self) -> Id<I> {
         if let Some(id) = self.free.pop() {
             return id;
         }
-        let id = Id(self.cur);
-        self.cur += 1;
-        id
+        let next = self.cur.next();
+        std::mem::replace(&mut self.cur, next)
     }
 
     #[allow(dead_code)]
-    pub fn free(&mut self, id: Id) {
+    pub fn free(&mut self, id: Id<I>) {
         self.free.push(id);
     }
 }
+
+impl<I: IdNum> Id<I> {
+    pub fn idx(&self) -> usize {
+        self.0.idx()
+    }
+    pub fn next(&self) -> Id<I> {
+        Self(self.0.next())
+    }
+    pub const fn preset(value: I) -> Self {
+        Self(value)
+    }
+}
+
+impl<I: IdNum> Default for IdTracker<I> {
+    fn default() -> Self {
+        Self {
+            free: Vec::new(),
+            cur: Id(I::first()),
+        }
+    }
+}
+
+pub trait IdNum {
+    fn first() -> Self;
+    fn next(&self) -> Self;
+    fn idx(&self) -> usize;
+}
+
+impl IdNum for u64 {
+    fn first() -> Self {
+        0
+    }
+
+    fn next(&self) -> Self {
+        self + 1
+    }
+
+    fn idx(&self) -> usize {
+        *self as usize
+    }
+}
+
+impl IdNum for u32 {
+    fn first() -> Self {
+        0
+    }
+
+    fn next(&self) -> Self {
+        self + 1
+    }
+
+    fn idx(&self) -> usize {
+        *self as usize
+    }
+}

src/util/mod.rs

@@ -1,9 +1,11 @@
+mod arena;
 mod borrow;
 mod change;
 mod id;
 mod math;
 mod refcount;
 
+pub(crate) use arena::*;
 pub(crate) use borrow::*;
 pub use change::*;
 pub(crate) use id::*;