all: split reusable components into workspace crates

utils/src/vecstorage.rs

@@ -0,0 +1,105 @@
+use std::{
+    mem::ManuallyDrop,
+    ops::{Deref, DerefMut},
+};
+
+macro_rules! assert_size_eq {
+    ($t:ty, $u:ty) => {{
+        struct AssertEqSize<T, U>(std::marker::PhantomData<T>, std::marker::PhantomData<U>);
+        impl<T, U> AssertEqSize<T, U> {
+            const VAL: usize = {
+                if std::mem::size_of::<T>() != std::mem::size_of::<U>() {
+                    panic!("Types have different size");
+                }
+                1
+            };
+        }
+        let _ = AssertEqSize::<$t, $u>::VAL;
+    }};
+}
+
+macro_rules! assert_align_eq {
+    ($t:ty, $u:ty) => {{
+        struct AssertEqAlign<T, U>(std::marker::PhantomData<T>, std::marker::PhantomData<U>);
+        impl<T, U> AssertEqAlign<T, U> {
+            const VAL: usize = {
+                if std::mem::align_of::<T>() != std::mem::align_of::<U>() {
+                    panic!("Types have different alignment");
+                }
+                1
+            };
+        }
+        let _ = AssertEqAlign::<$t, $u>::VAL;
+    }};
+}
+
+pub struct VecStorage<T> {
+    ptr: *mut T,
+    cap: usize,
+}
+
+impl<T> Default for VecStorage<T> {
+    fn default() -> Self {
+        let mut v = ManuallyDrop::new(vec![]);
+        Self {
+            ptr: v.as_mut_ptr(),
+            cap: v.capacity(),
+        }
+    }
+}
+
+impl<T> VecStorage<T> {
+    pub fn take<'a>(&'a mut self) -> RealizedVec<'a, T, T> {
+        self.take_as()
+    }
+
+    pub fn take_as<'a, U>(&'a mut self) -> RealizedVec<'a, T, U> {
+        assert_size_eq!(T, U);
+        assert_align_eq!(T, U);
+        unsafe {
+            RealizedVec {
+                vec: ManuallyDrop::new(self.to_vector()),
+                storage: self,
+            }
+        }
+    }
+
+    unsafe fn to_vector<U>(&mut self) -> Vec<U> {
+        unsafe { Vec::from_raw_parts(self.ptr as _, 0, self.cap) }
+    }
+}
+
+impl<T> Drop for VecStorage<T> {
+    fn drop(&mut self) {
+        unsafe {
+            drop(self.to_vector::<T>());
+        }
+    }
+}
+
+pub struct RealizedVec<'a, T, U> {
+    vec: ManuallyDrop<Vec<U>>,
+    storage: &'a mut VecStorage<T>,
+}
+
+impl<'a, T, U> Drop for RealizedVec<'a, T, U> {
+    fn drop(&mut self) {
+        self.vec.clear();
+        self.storage.ptr = self.vec.as_mut_ptr() as _;
+        self.storage.cap = self.vec.capacity();
+    }
+}
+
+impl<'a, T, U> Deref for RealizedVec<'a, T, U> {
+    type Target = Vec<U>;
+
+    fn deref(&self) -> &Self::Target {
+        self.vec.deref()
+    }
+}
+
+impl<'a, T, U> DerefMut for RealizedVec<'a, T, U> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.vec.deref_mut()
+    }
+}