Initial commit

Author: GnomedDev

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,14 @@
+[package]
+name = "small-fixed-array"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.193", optional = true }
+typesize = { version = "0.1.3", optional = true }
+
+[features]
+typesize = ["dep:typesize"]
+serde = ["dep:serde"]

Cargo.toml

@@ -0,0 +1,167 @@
+use std::{fmt::Debug, hash::Hash};
+
+use crate::non_empty_array::NonEmptyFixedArray;
+
+/// A fixed size array with length provided at creation with length denoted in [`u32`]
+#[derive(Clone)]
+pub struct FixedArray<T>(Option<NonEmptyFixedArray<T>>);
+
+impl<T> FixedArray<T> {
+    pub fn new() -> Self {
+        Self::empty()
+    }
+
+    pub fn empty() -> Self {
+        Self(None)
+    }
+
+    pub fn len(&self) -> u32 {
+        self.0
+            .as_ref()
+            .map(NonEmptyFixedArray::small_len)
+            .unwrap_or_default()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_none()
+    }
+
+    pub fn as_slice(&self) -> &[T] {
+        self
+    }
+
+    pub fn into_vec(self) -> Vec<T> {
+        self.into()
+    }
+}
+
+impl<T> Default for FixedArray<T> {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl<T> std::ops::Deref for FixedArray<T> {
+    type Target = [T];
+    fn deref(&self) -> &Self::Target {
+        self.0
+            .as_ref()
+            .map(NonEmptyFixedArray::as_slice)
+            .unwrap_or_default()
+    }
+}
+
+impl<T> std::ops::DerefMut for FixedArray<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.0
+            .as_mut()
+            .map(NonEmptyFixedArray::as_mut_slice)
+            .unwrap_or_default()
+    }
+}
+
+impl<T> std::ops::Index<u32> for FixedArray<T> {
+    type Output = T;
+    fn index(&self, index: u32) -> &Self::Output {
+        let inner: &[T] = self;
+        &inner[index as usize]
+    }
+}
+
+impl<T> std::ops::IndexMut<u32> for FixedArray<T> {
+    fn index_mut(&mut self, index: u32) -> &mut Self::Output {
+        let inner: &mut [T] = self;
+        &mut inner[index as usize]
+    }
+}
+
+impl<T: Hash> Hash for FixedArray<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_slice().hash(state)
+    }
+}
+
+impl<T: PartialEq> PartialEq for FixedArray<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_slice().eq(other.as_slice())
+    }
+}
+
+impl<T: Eq> Eq for FixedArray<T> {}
+
+impl<T: Debug> Debug for FixedArray<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        <[T] as Debug>::fmt(self, f)
+    }
+}
+
+impl<T> IntoIterator for FixedArray<T> {
+    type Item = T;
+    type IntoIter = std::vec::IntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.into_vec().into_iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a FixedArray<T> {
+    type Item = &'a T;
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.as_slice().iter()
+    }
+}
+
+impl<T> std::iter::FromIterator<T> for FixedArray<T> {
+    fn from_iter<Iter: IntoIterator<Item = T>>(iter: Iter) -> Self {
+        Vec::from_iter(iter).into()
+    }
+}
+
+impl<T> From<FixedArray<T>> for Box<[T]> {
+    fn from(value: FixedArray<T>) -> Self {
+        value.0.map(Box::from).unwrap_or_default()
+    }
+}
+
+impl<T> From<FixedArray<T>> for Vec<T> {
+    fn from(value: FixedArray<T>) -> Self {
+        let boxed_array: Box<[T]> = value.into();
+        boxed_array.into_vec()
+    }
+}
+
+impl<T> From<Box<[T]>> for FixedArray<T> {
+    fn from(boxed_array: Box<[T]>) -> Self {
+        Self((!boxed_array.is_empty()).then(|| NonEmptyFixedArray::from(boxed_array)))
+    }
+}
+
+impl<T> From<Vec<T>> for FixedArray<T> {
+    fn from(value: Vec<T>) -> Self {
+        let boxed_array = value.into_boxed_slice();
+        Self::from(boxed_array)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, T: serde::Deserialize<'de>> serde::Deserialize<'de> for FixedArray<T> {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        Box::<[T]>::deserialize(deserializer).map(Self::from)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<T: serde::Serialize> serde::Serialize for FixedArray<T> {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.as_slice().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "typesize")]
+impl<T: typesize::TypeSize> typesize::TypeSize for FixedArray<T> {
+    fn extra_size(&self) -> usize {
+        self.iter().map(T::get_size).sum()
+    }
+}

src/array.rs

@@ -0,0 +1,7 @@
+mod array;
+mod string;
+// Internal only!
+mod non_empty_array;
+
+pub use array::FixedArray;
+pub use string::FixedString;

src/lib.rs

@@ -0,0 +1,78 @@
+use std::{mem::ManuallyDrop, num::NonZeroU32, ptr::NonNull};
+
+#[repr(packed)]
+pub(crate) struct NonEmptyFixedArray<T> {
+    ptr: NonNull<T>,
+    len: NonZeroU32,
+}
+
+impl<T> NonEmptyFixedArray<T> {
+    pub(crate) fn small_len(&self) -> u32 {
+        self.len.get()
+    }
+
+    fn len(&self) -> usize {
+        self.small_len() as usize
+    }
+
+    pub(crate) fn as_slice(&self) -> &[T] {
+        // SAFETY: `self.ptr` and `self.len` are both valid and derived from `Box<[T]>`.
+        unsafe { std::slice::from_raw_parts(self.ptr.as_ptr(), self.len()) }
+    }
+
+    pub(crate) fn as_mut_slice(&mut self) -> &mut [T] {
+        // SAFETY: `self.ptr` and `self.len` are both valid and derived from `Box<[T]>`.
+        unsafe { std::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len()) }
+    }
+
+    /// Converts the NonEmptyFixedArray to it's original [`Box<T>`].
+    ///
+    /// # Safety
+    /// `self` must never be used again, and it is highly recommended to wrap in ManuallyDrop before calling.
+    pub(crate) unsafe fn as_box(&mut self) -> Box<[T]> {
+        let slice = self.as_mut_slice();
+
+        // SAFETY: `self` has been derived from `Box<[T]>`
+        unsafe { Box::from_raw(slice as *mut [T]) }
+    }
+}
+
+impl<T> From<Box<[T]>> for NonEmptyFixedArray<T> {
+    fn from(boxed_array: Box<[T]>) -> Self {
+        let len = NonZeroU32::new(boxed_array.len().try_into().unwrap()).unwrap();
+        let array_ptr = Box::into_raw(boxed_array) as *mut T;
+
+        NonEmptyFixedArray {
+            ptr: NonNull::new(array_ptr).expect("Box ptr != nullptr"),
+            len,
+        }
+    }
+}
+
+impl<T> From<NonEmptyFixedArray<T>> for Box<[T]> {
+    fn from(value: NonEmptyFixedArray<T>) -> Self {
+        let mut value = ManuallyDrop::new(value);
+        unsafe {
+            // SAFETY: We don't use value again, and it is ManuallyDrop.
+            value.as_box()
+        }
+    }
+}
+
+impl<T: Clone> Clone for NonEmptyFixedArray<T> {
+    fn clone(&self) -> Self {
+        self.as_slice().to_vec().into_boxed_slice().into()
+    }
+}
+
+impl<T> Drop for NonEmptyFixedArray<T> {
+    fn drop(&mut self) {
+        unsafe {
+            // SAFETY: We never use `self` again, and we are in the drop impl.
+            self.as_box();
+        }
+    }
+}
+
+unsafe impl<T: Send> Send for NonEmptyFixedArray<T> {}
+unsafe impl<T: Sync> Sync for NonEmptyFixedArray<T> {}