Add as_slice and as_mut_slice for Packed*Array

godot-core/src/builtin/packed_array.rs

@@ -258,6 +258,38 @@ macro_rules! impl_packed_array {
                 self.as_inner().sort();
             }
 
+            /// Extracts a slice of the entire array.
+            pub fn as_slice<'a>(&'a self) -> &'a [$Element] {
+                let len = self.len();
+
+                if len == 0 {
+                    return &[];
+                }
+
+                let data = self.ptr(0);
+                // SAFETY: Data is valid for len elements as it was allocated by the array.
+                // Data is not aliased as it is CoW.
+                unsafe {
+                    std::slice::from_raw_parts(data, len)
+                }
+            }
+
+            /// Extracts a mutable slice of the entire array.
+            pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [$Element] {
+                let len = self.len();
+
+                if len == 0 {
+                    return &mut [];
+                }
+
+                let data = self.ptr_mut(0);
+                // SAFETY: Data is valid for len elements as it was allocated by the array.
+                // Data is not aliased as it is CoW.
+                unsafe {
+                    std::slice::from_raw_parts_mut(data, len)
+                }
+            }
+
             /// Asserts that the given index refers to an existing element.
             ///
             /// # Panics

itest/rust/src/packed_array_test.rs

@@ -28,6 +28,8 @@ pub fn run() -> bool {
     ok &= packed_array_extend();
     ok &= packed_array_reverse();
     ok &= packed_array_sort();
+    ok &= packed_array_as_slice();
+    ok &= packed_array_is_mut_unique();
     ok
 }
 
@@ -200,3 +202,41 @@ fn packed_array_reverse() {
     array.reverse();
     assert_eq!(array.to_vec(), vec![2, 1]);
 }
+
+#[itest]
+fn packed_array_as_slice() {
+    let vec = vec![1, 2];
+    let array = PackedByteArray::from(vec.as_slice());
+    assert_eq!(array.as_slice(), vec.as_slice());
+
+    assert_eq!(
+        PackedByteArray::new().as_slice(),
+        &[],
+        "array is empty, but still a valid slice"
+    );
+}
+
+#[itest]
+fn packed_array_is_mut_unique() {
+    let array1 = PackedByteArray::from(&[1, 2]);
+    let mut array2 = array1.clone();
+
+    assert_eq!(
+        array1.as_slice().as_ptr(),
+        array2.as_slice().as_ptr(),
+        "arrays should share the same buffer"
+    );
+
+    // array2 should become a copy of array1 since rc > 1.
+    array2.as_mut_slice();
+    assert_ne!(
+        array1.as_slice().as_ptr(),
+        array2.as_slice().as_ptr(),
+        "arrays should not share the same buffer after a mutable access"
+    );
+    assert_eq!(
+        array1.as_slice(),
+        array2.as_slice(),
+        "array2 should be a copy of array1"
+    );
+}