CopyLocalVec introduced, Eq and Clone (#12)

* Clone and Eq implemented

* CopyLocalVec added

Author: m-rinaldi

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "local_vec"
-version = "0.4.0"
-edition = "2018"
+version = "0.5.0"
+edition = "2021"
 authors = ["Jorge Rinaldi <jrg.rinaldi@gmail.com>"]
 license = "MIT"
 repository = "https://github.com/m-rinaldi/local_vec"

src/clone.rs

@@ -0,0 +1,24 @@
+use crate::LocalVecImpl;
+
+impl<T: Clone, const N: usize> Clone for LocalVecImpl<T, N> {
+    fn clone(&self) -> Self {
+        let mut cloned = Self::new();
+        for i in 0..self.len() {
+            cloned.push(self[i].clone());
+        }
+        debug_assert_eq!(cloned.len(), self.len());
+        cloned
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_clone() {
+        let vec = LocalVecImpl::<_, 3>::from_array([1, 2, 3]);
+        let cloned = vec.clone();
+        assert_eq!(vec, cloned);
+    }
+}

src/deref.rs

@@ -1,7 +1,7 @@
-use crate::LocalVec;
+use crate::LocalVecImpl;
 use std::ops::{Deref, DerefMut};
 
-impl<T, const N: usize> Deref for LocalVec<T, N> {
+impl<T, const N: usize> Deref for LocalVecImpl<T, N> {
     type Target = [T];
 
     fn deref(&self) -> &[T] {
@@ -11,7 +11,7 @@ impl<T, const N: usize> Deref for LocalVec<T, N> {
     }
 }
 
-impl<T, const N: usize> DerefMut for LocalVec<T, N> {
+impl<T, const N: usize> DerefMut for LocalVecImpl<T, N> {
     fn deref_mut(&mut self) -> &mut [T] {
         unsafe {
             std::slice::from_raw_parts_mut(self.as_mut_ptr(), self.len)
@@ -26,7 +26,7 @@ mod tests {
     #[test]
     fn test_deref() {
         let arr = [33; 3];
-        let vec = LocalVec::<_, 8>::from_array(arr);
+        let vec = LocalVecImpl::<_, 8>::from_array(arr);
         let slc = vec.deref();
         assert_eq!(slc.len(), 3);
         assert_eq!(slc, arr);
@@ -35,22 +35,22 @@ mod tests {
     #[test]
     fn test_deref_mut() {
         let arr = [33; 3];
-        let mut vec = LocalVec::<_, 8>::from_array(arr);
+        let mut vec = LocalVecImpl::<_, 8>::from_array(arr);
         let slc = vec.deref_mut();
         assert_eq!(slc.len(), 3);
         assert_eq!(slc, arr);
     }
 
     #[test]
     fn test_deref_zero_size() {
-        let vec = LocalVec::<u8, 0>::new();
+        let vec = LocalVecImpl::<u8, 0>::new();
         let slc = vec.deref();
         assert_eq!(slc.len(), 0);
     }
 
     #[test]
     fn test_deref_mut_zero_size() {
-        let mut vec = LocalVec::<u8, 0>::new();
+        let mut vec = LocalVecImpl::<u8, 0>::new();
         let slc = vec.deref_mut();
         assert_eq!(slc.len(), 0);
     }

src/drop.rs

@@ -2,6 +2,8 @@ use crate::LocalVec;
 
 impl <T, const N: usize> Drop for LocalVec<T, N> {
     fn drop(&mut self) {
+        // TODO check the dropping order
+        // it should be the same as in a built-in array
         self.clear();
     }
 }

src/eq.rs

@@ -0,0 +1,46 @@
+use crate::{LocalVecImpl, LenType};
+
+// TODO generalize further for comparing LocalVec values of different capacities
+impl<T: PartialEq, const N: LenType> PartialEq for LocalVecImpl<T, N> {
+    fn eq(&self, other: &Self) -> bool {
+        if self.len != other.len {
+            return false;
+        }
+
+        for i in 0..self.len() {
+            if self[i] != other[i] {
+                return false;
+            }
+        }
+
+        true
+    }
+}
+
+impl<T: Eq, const N: LenType> Eq for LocalVecImpl<T, N> {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_eq_equal() {
+        let vec = LocalVecImpl::<_, 3>::from_array([1, 2, 3]);
+        let cloned = vec.clone();
+        assert!(vec == cloned);
+    }
+
+    #[test]
+    fn test_eq_not_equal() {
+        let a = LocalVecImpl::<_, 3>::from_array([1, 2, 3]);
+        let b = LocalVecImpl::<_, 3>::from_array([1, 2, 5]);
+        assert!(a != b);
+    }
+    
+    #[test]
+    fn test_eq_diff_len() {
+        let a = LocalVecImpl::<_, 4>::from_array([1, 2, 3]);
+        let b = LocalVecImpl::<_, 4>::from_array([1, 2, 3, 4]);
+        assert!(a != b);
+    }
+}

src/lib.rs

@@ -1,33 +1,65 @@
 use std::mem::MaybeUninit;
 
+mod clone;
 mod drop;
 mod index;
 mod from;
 mod deref;
 mod iter;
 mod extend;
+mod eq;
 
-#[derive(Debug)]
 /// A fixed-capacity vector that directly stores its elements  
-pub struct LocalVec<T, const N: usize> {
+#[derive(Eq, PartialEq, Clone, Debug)]
+pub struct LocalVec<T, const N: usize>(LocalVecImpl<T, N>);
+
+/// /// A fixed-capacity vector, for Copy types, that directly stores its elements 
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub struct CopyLocalVec<T: Copy, const N: usize>(LocalVecImpl<T, N>);
+
+#[derive(Copy, Debug)]
+pub struct LocalVecImpl<T, const N: usize> {
     buf: [MaybeUninit<T>; N],
-    len: usize,
+    len: LenType,
 }
 
+// TODO use instead of usize
+type LenType = usize;
+
 impl<T, const N: usize> LocalVec<T, N> {
     pub fn new() -> Self {
+        Self(LocalVecImpl::new())
+    }
+
+    pub fn from_array<const M: usize>(arr: [T; M]) -> Self {
+        Self(LocalVecImpl::from_array(arr))
+    }
+}
+
+impl<T: Copy, const N: usize> CopyLocalVec<T, N> {
+    pub fn new() -> Self {
+        Self(LocalVecImpl::new())
+    }
+
+    pub fn from_array<const M: usize>(arr: [T; M]) -> Self {
+        Self(LocalVecImpl::from_array(arr))
+    }
+}
+
+impl<T, const N: usize> LocalVecImpl<T, N> {
+    fn new() -> Self {
         let buf: [MaybeUninit<T>; N] = unsafe {
             MaybeUninit::uninit().assume_init()
         };
 
-        LocalVec {
+        LocalVecImpl {
             buf,
             len: 0,
         }
     }
 
     // TODO implement From<[T; N]> on top of this?
-    pub fn from_array<const M: usize>(arr: [T; M]) -> Self {
+    fn from_array<const M: usize>(arr: [T; M]) -> Self {
         // TODO check at compile time
         assert!(M <= N, "can't store {} elements with a capacity of {}", M, N);
 
@@ -122,21 +154,49 @@ impl<T, const N: usize> LocalVec<T, N> {
     }
 }
 
+impl<T, const N: usize> std::ops::Deref for LocalVec<T, N> {
+    type Target = LocalVecImpl<T, N>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: Copy, const N: usize> std::ops::Deref for CopyLocalVec<T, N> {
+    type Target = LocalVecImpl<T, N>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T, const N: usize> std::ops::DerefMut for LocalVec<T, N> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T: Copy, const N: usize> std::ops::DerefMut for CopyLocalVec<T, N> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use super::LocalVec;
+    use super::LocalVecImpl;
 
     #[test]
     fn test_new() {
-        let vec = LocalVec::<u32, 4>::new();
+        let vec = LocalVecImpl::<u32, 4>::new();
         assert_eq!(vec.len(), 0);
         assert_eq!(vec.capacity(), 4);
     }
 
     #[test]
     #[should_panic]
     fn test_push_on_full() {
-        let mut vec = LocalVec::<_, 1>::new();
+        let mut vec = LocalVecImpl::<_, 1>::new();
         vec.push(0);
 
         assert!(vec.is_full());
@@ -146,7 +206,7 @@ mod tests {
 
     #[test]
     fn test_push() {
-        let mut vec = LocalVec::<_, 3>::new();
+        let mut vec = LocalVecImpl::<_, 3>::new();
 
         assert!(vec.is_empty());
         assert_eq!(vec.len(), 0);
@@ -164,7 +224,7 @@ mod tests {
 
     #[test]
     fn test_pop_on_empty() {
-        let mut vec = LocalVec::<_, 1>::new();
+        let mut vec = LocalVecImpl::<_, 1>::new();
         assert!(vec.is_empty());
         matches!(vec.pop(), None);
 
@@ -178,7 +238,7 @@ mod tests {
 
     #[test]
     fn test_push_and_pop() {
-        let mut vec = LocalVec::<_, 4>::new();
+        let mut vec = LocalVecImpl::<_, 4>::new();
         assert!(vec.is_empty());
         matches!(vec.pop(), None);
 
@@ -195,7 +255,7 @@ mod tests {
 
     #[test]
     fn test_clear() {
-        let mut vec = LocalVec::<_,3>::new();
+        let mut vec = LocalVecImpl::<_,3>::new();
         vec.clear();
         assert!(vec.is_empty());
 
@@ -214,29 +274,29 @@ mod tests {
     #[should_panic]
     fn test_from_capacity_exceeding_array() {
         let arr = [0; 4];
-        let _ = LocalVec::<_,3>::from_array(arr);
+        let _ = LocalVecImpl::<_,3>::from_array(arr);
     }
 
     #[test]
     fn test_from_array() {
         let arr = [0; 4];
-        let vec = LocalVec::<_, 4>::from_array(arr);
+        let vec = LocalVecImpl::<_, 4>::from_array(arr);
 
         assert_eq!(vec.len(), 4);
     }
 
     #[test]
     fn test_from_smaller_array() {
         let arr = [0; 4];
-        let vec = LocalVec::<_, 6>::from_array(arr);
+        let vec = LocalVecImpl::<_, 6>::from_array(arr);
 
         assert_eq!(vec.len(), 4);
     }
 
     #[test]
     fn test_set_len() {
         let arr = [7; 4];
-        let mut vec = LocalVec::<_, 6>::from_array(arr);
+        let mut vec = LocalVecImpl::<_, 6>::from_array(arr);
 
         assert_eq!(vec.len(), 4);
         unsafe {
@@ -248,7 +308,7 @@ mod tests {
     #[test]
     fn test_take_array() {
         let arr = [7; 4];
-        let mut vec = LocalVec::<_, 6>::from_array(arr);
+        let mut vec = LocalVecImpl::<_, 6>::from_array(arr);
         assert_eq!(vec.len(), 4);
         let _ = vec.take_array();
         assert_eq!(vec.len(), 0);
@@ -257,29 +317,29 @@ mod tests {
     #[test]
     fn test_as_ptr() {
         let arr = [0xff; 3];
-        let vec = LocalVec::<_, 8>::from_array(arr);
+        let vec = LocalVecImpl::<_, 8>::from_array(arr);
         let ptr = vec.as_ptr();
         assert_eq!(ptr, &vec[0] as *const i32);
     }
 
     #[test]
     fn test_as_mut_ptr() {
         let arr = [0xff; 3];
-        let mut vec = LocalVec::<_, 8>::from_array(arr);
+        let mut vec = LocalVecImpl::<_, 8>::from_array(arr);
         let ptr = vec.as_mut_ptr();
         assert_eq!(ptr, &mut vec[0] as *mut i32);
     }
 
     #[test]
     fn test_as_ptr_zero_size() {
-        let vec = LocalVec::<u8, 0>::new();
+        let vec = LocalVecImpl::<u8, 0>::new();
         let ptr = vec.as_ptr();
         assert!(ptr.is_null());
     }
 
     #[test]
     fn test_as_mut_ptr_zero_size() {
-        let mut vec = LocalVec::<u8, 0>::new();
+        let mut vec = LocalVecImpl::<u8, 0>::new();
         let ptr = vec.as_mut_ptr();
         assert!(ptr.is_null());
     }