enum discriminant

Author: omfj

soavec_derive/debug.rs

@@ -0,0 +1,182 @@
+#[repr(C, u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum CustomDiscriminantsDiscriminant {
+    A = 10,
+    B = 20,
+    C,
+    D = some_function(),
+}
+#[allow(dead_code)]
+#[derive(Copy, Clone)]
+union CustomDiscriminantsField0 {
+    a: (),
+    b: String,
+    c: (),
+    d: (),
+}
+#[allow(dead_code)]
+#[derive(Copy, Clone)]
+union CustomDiscriminantsField1 {
+    a: (),
+    b: u32,
+    c: (),
+    d: (),
+}
+#[allow(dead_code)]
+struct CustomDiscriminantsRef<'soa> {
+    discriminant: &'soa CustomDiscriminantsDiscriminant,
+    _0: &'soa CustomDiscriminantsField0,
+    _1: &'soa CustomDiscriminantsField1,
+}
+impl<'soa> Copy for CustomDiscriminantsRef<'soa> {}
+impl<'soa> Clone for CustomDiscriminantsRef<'soa> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[allow(dead_code)]
+struct CustomDiscriminantsMut<'soa> {
+    discriminant: &'soa CustomDiscriminantsDiscriminant,
+    _0: &'soa mut CustomDiscriminantsField0,
+    _1: &'soa mut CustomDiscriminantsField1,
+}
+#[allow(dead_code)]
+struct CustomDiscriminantsSlice<'soa> {
+    discriminant: &'soa [CustomDiscriminantsDiscriminant],
+    _0: &'soa [CustomDiscriminantsField0],
+    _1: &'soa [CustomDiscriminantsField1],
+}
+impl<'soa> Copy for CustomDiscriminantsSlice<'soa> {}
+impl<'soa> Clone for CustomDiscriminantsSlice<'soa> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[allow(dead_code)]
+struct CustomDiscriminantsSliceMut<'soa> {
+    discriminant: &'soa mut [CustomDiscriminantsDiscriminant],
+    _0: &'soa mut [CustomDiscriminantsField0],
+    _1: &'soa mut [CustomDiscriminantsField1],
+}
+unsafe impl soavec::SoAble for CustomDiscriminants {
+    type TupleRepr = (
+        CustomDiscriminantsDiscriminant,
+        CustomDiscriminantsField0,
+        CustomDiscriminantsField1,
+    );
+    type Ref<'soa>
+        = CustomDiscriminantsRef<'soa>
+    where
+        Self: 'soa;
+    type Mut<'soa>
+        = CustomDiscriminantsMut<'soa>
+    where
+        Self: 'soa;
+    type Slice<'soa>
+        = CustomDiscriminantsSlice<'soa>
+    where
+        Self: 'soa;
+    type SliceMut<'soa>
+        = CustomDiscriminantsSliceMut<'soa>
+    where
+        Self: 'soa;
+    fn into_tuple(value: Self) -> Self::TupleRepr {
+        match value {
+            Self::A => (
+                CustomDiscriminantsDiscriminant::A,
+                CustomDiscriminantsField0 { a: () },
+                CustomDiscriminantsField1 { a: () },
+            ),
+            Self::B(__field0, __field1) => (
+                CustomDiscriminantsDiscriminant::B,
+                CustomDiscriminantsField0 { b: __field0 },
+                CustomDiscriminantsField1 { b: __field1 },
+            ),
+            Self::C => (
+                CustomDiscriminantsDiscriminant::C,
+                CustomDiscriminantsField0 { c: () },
+                CustomDiscriminantsField1 { c: () },
+            ),
+            Self::D => (
+                CustomDiscriminantsDiscriminant::D,
+                CustomDiscriminantsField0 { d: () },
+                CustomDiscriminantsField1 { d: () },
+            ),
+        }
+    }
+    fn from_tuple(value: Self::TupleRepr) -> Self {
+        let (__disc, __union0, __union1) = value;
+        match __disc {
+            CustomDiscriminantsDiscriminant::A => Self::A,
+            CustomDiscriminantsDiscriminant::B => {
+                let __field0 = unsafe { __union0.b };
+                let __field1 = unsafe { __union1.b };
+                Self::B(__field0, __field1)
+            }
+            CustomDiscriminantsDiscriminant::C => Self::C,
+            CustomDiscriminantsDiscriminant::D => Self::D,
+        }
+    }
+    fn as_ref<'soa>(
+        _: std::marker::PhantomData<&'soa Self>,
+        value: <Self::TupleRepr as soavec::SoATuple>::Pointers,
+    ) -> Self::Ref<'soa> {
+        let (__disc_ptr, __union0, __union1) = value;
+        unsafe {
+            CustomDiscriminantsRef {
+                discriminant: &*(__disc_ptr.as_ptr() as *const _),
+                _0: __union0.as_ref(),
+                _1: __union1.as_ref(),
+            }
+        }
+    }
+    fn as_mut<'soa>(
+        _: std::marker::PhantomData<&'soa mut Self>,
+        value: <Self::TupleRepr as soavec::SoATuple>::Pointers,
+    ) -> Self::Mut<'soa> {
+        let (__disc_ptr, mut __union0, mut __union1) = value;
+        unsafe {
+            CustomDiscriminantsMut {
+                discriminant: &*(__disc_ptr.as_ptr() as *const _),
+                _0: __union0.as_mut(),
+                _1: __union1.as_mut(),
+            }
+        }
+    }
+    fn as_slice<'soa>(
+        _: std::marker::PhantomData<&'soa Self>,
+        value: <Self::TupleRepr as soavec::SoATuple>::Pointers,
+        len: u32,
+    ) -> Self::Slice<'soa> {
+        let __soa_len = len as usize;
+        let (__disc_ptr, __union0, __union1) = value;
+        unsafe {
+            CustomDiscriminantsSlice {
+                discriminant: core::slice::from_raw_parts(
+                    __disc_ptr.as_ptr() as *const _,
+                    __soa_len,
+                ),
+                _0: core::slice::from_raw_parts(__union0.as_ptr(), __soa_len),
+                _1: core::slice::from_raw_parts(__union1.as_ptr(), __soa_len),
+            }
+        }
+    }
+    fn as_mut_slice<'soa>(
+        _: std::marker::PhantomData<&'soa mut Self>,
+        value: <Self::TupleRepr as soavec::SoATuple>::Pointers,
+        len: u32,
+    ) -> Self::SliceMut<'soa> {
+        let __soa_len = len as usize;
+        let (__disc_ptr, __union0, __union1) = value;
+        unsafe {
+            CustomDiscriminantsSliceMut {
+                discriminant: core::slice::from_raw_parts_mut(
+                    __disc_ptr.as_ptr() as *mut _,
+                    __soa_len,
+                ),
+                _0: core::slice::from_raw_parts_mut(__union0.as_ptr(), __soa_len),
+                _1: core::slice::from_raw_parts_mut(__union1.as_ptr(), __soa_len),
+            }
+        }
+    }
+}