feat(vec): add extend() method for batch element insertion

src/base_vec.rs

@@ -227,6 +227,22 @@ impl<T: Storable, M: Memory> BaseVec<T, M> {
         Ok(())
     }
 
+    /// Adds multiple items at the end of the vector.
+    ///
+    /// Complexity: O(n * max_size(T))
+    pub fn extend(&self, items: &[T]) -> Result<(), GrowFailed> {
+        let start_index = self.len();
+        let slot = slot_size::<T>() as u64;
+        for (i, item) in items.iter().enumerate() {
+            let offset = DATA_OFFSET + slot * (start_index + i as u64);
+            let bytes = item.to_bytes_checked();
+            let data_offset = self.write_entry_size(offset, bytes.len() as u32)?;
+            safe_write(&self.memory, data_offset, bytes.borrow())?;
+        }
+        self.set_len(start_index + items.len() as u64);
+        Ok(())
+    }
+
     /// Removes the item at the end of the vector.
     ///
     /// Complexity: O(max_size(T))

src/vec.rs

@@ -89,6 +89,15 @@ impl<T: Storable, M: Memory> Vec<T, M> {
             .expect("Failed to push item to the vector");
     }
 
+    /// Adds multiple items at the end of the vector.
+    ///
+    /// Complexity: O(n * max_size(T))
+    pub fn extend(&self, items: &[T]) {
+        self.0
+            .extend(items)
+            .expect("Failed to extend the vector");
+    }
+
     /// Removes the item at the end of the vector.
     ///
     /// Complexity: O(max_size(T))

src/vec/tests.rs

@@ -350,3 +350,45 @@ fn set_last_element_to_large_blob() {
     // Store a large blob that would require growing the memory.
     sv.set(0, &Blob::try_from(vec![1; 65536].as_slice()).unwrap());
 }
+
+#[test]
+fn extend_empty_slice() {
+    let sv = StableVec::<u64, M>::new(M::default());
+    sv.extend(&[]);
+    assert_eq!(sv.len(), 0);
+    assert!(sv.is_empty());
+}
+
+#[test]
+fn extend_basic() {
+    let sv = StableVec::<u64, M>::new(M::default());
+    sv.extend(&[1, 2, 3]);
+    assert_eq!(sv.len(), 3);
+    assert_eq!(sv.to_vec(), vec![1, 2, 3]);
+}
+
+#[test]
+fn extend_after_push() {
+    let sv = StableVec::<u64, M>::new(M::default());
+    sv.push(&0);
+    sv.extend(&[1, 2, 3]);
+    assert_eq!(sv.len(), 4);
+    assert_eq!(sv.to_vec(), vec![0, 1, 2, 3]);
+}
+
+#[test]
+fn extend_multiple_calls() {
+    let sv = StableVec::<u64, M>::new(M::default());
+    sv.extend(&[1, 2]);
+    sv.extend(&[3, 4]);
+    assert_eq!(sv.to_vec(), vec![1, 2, 3, 4]);
+}
+
+#[test]
+fn extend_persistence() {
+    let sv = StableVec::<u64, M>::new(M::default());
+    sv.extend(&[10, 20, 30]);
+    let mem = sv.into_memory();
+    let sv = StableVec::<u64, M>::init(mem);
+    assert_eq!(sv.to_vec(), vec![10, 20, 30]);
+}