Implement clone (#35)

Author: andreiavrammsd

fuzz/fuzz_targets/static_vector.rs

@@ -20,6 +20,8 @@ fuzz_target!(|data: &[u8]| {
     let mut prev_byte = None;
 
     for (i, &byte) in data.iter().enumerate() {
+        assert_eq!(vec.as_slice(), vec.clone().as_slice());
+
         let is_full_before_push = vec.is_full();
         let result = vec.push(byte);
         let is_full_after_push = vec.is_full();

src/lib.rs

@@ -190,13 +190,11 @@ impl<T, const CAPACITY: usize> Vec<T, CAPACITY> {
     #[doc(alias("add", "append", "insert"))]
     pub fn push(&mut self, value: T) -> Result<(), CapacityError> {
         if self.is_full() {
-            return Err(CapacityError);
+            Err(CapacityError)
+        } else {
+            self.push_unchecked(value);
+            Ok(())
         }
-
-        self.data[self.length].write(value);
-        self.length += 1;
-
-        Ok(())
     }
 
     /// Removes all elements. Size will be zero.
@@ -272,14 +270,14 @@ impl<T, const CAPACITY: usize> Vec<T, CAPACITY> {
         }
 
         if new_length > self.length {
-            for i in self.length..new_length {
-                self.data[i].write(T::default());
+            while self.length < new_length {
+                self.push_unchecked(T::default());
             }
         } else {
             self.drop_range(new_length, self.length);
+            self.length = new_length;
         }
 
-        self.length = new_length;
         Ok(())
     }
 
@@ -632,15 +630,21 @@ impl<T, const CAPACITY: usize> Vec<T, CAPACITY> {
             return Err(CapacityError);
         }
 
-        for (index, value) in slice.iter().enumerate() {
-            self.data[self.len() + index].write(value.clone());
+        for value in slice {
+            self.push_unchecked(value.clone());
         }
 
-        self.length += slice.len();
-
         Ok(())
     }
 
+    /// Adds the given `value` to the end of the vector without checking bounds.
+    /// For internal and controlled use only.
+    fn push_unchecked(&mut self, value: T) {
+        debug_assert!(!self.is_full(), "cannot push to full vector");
+        self.data[self.length].write(value);
+        self.length += 1;
+    }
+
     /// Drops all elements in given range. Needed when elements are considered to be going out of scope.
     /// E.g.: when the vector is going out of scope, when methods such as [`Vec::clear()`] and [`Vec::set_len()`] are called.
     fn drop_range(&mut self, from: usize, to: usize) {
@@ -661,6 +665,16 @@ impl<T, const CAPACITY: usize> Drop for Vec<T, CAPACITY> {
     }
 }
 
+impl<T: Clone, const CAPACITY: usize> Clone for Vec<T, CAPACITY> {
+    fn clone(&self) -> Self {
+        let mut vec = Self::new();
+        for value in self {
+            vec.push_unchecked(value.clone());
+        }
+        vec
+    }
+}
+
 /// Immutable iterator over a [`Vec`].
 ///
 /// Created by calling [`Vec::iter()`].
@@ -1133,6 +1147,17 @@ mod tests {
         assert_eq!(dst.as_slice(), [1, 2, 3]);
     }
 
+    #[test]
+    fn clone() {
+        let mut vec = Vec::<i32, 5>::new();
+        let elements = [1, 2, 3];
+        vec.extend_from_slice(&elements).unwrap();
+
+        let new = vec.clone();
+        assert_eq!(new.len(), 3);
+        assert_eq!(new.as_slice(), elements);
+    }
+
     #[test]
     fn construct_should_not_create_default_elements() {
         let _ = Vec::<Struct, 10>::new();