ringbuffer_trait: add extend_from_slice

src/lib.rs

@@ -1376,7 +1376,7 @@ mod tests {
             parent: Option<RefMut<'a, DropTest>>,
         }
 
-        impl<'a> Drop for Dropee<'a> {
+        impl Drop for Dropee<'_> {
             fn drop(&mut self) {
                 if let Some(parent) = &mut self.parent {
                     parent.flag = true;

src/ringbuffer_trait.rs

@@ -86,7 +86,6 @@ pub unsafe trait RingBuffer<T>:
     ///
     /// Cycles around if capacity is reached.
     /// Forms a more natural counterpart to [`dequeue`](RingBuffer::dequeue).
-    /// An alias is provided with [`push`](RingBuffer::push).
     fn enqueue(&mut self, value: T) -> Option<T>;
 
     /// dequeues the top item off the ringbuffer, and moves this item out.
@@ -237,6 +236,18 @@ pub unsafe trait RingBuffer<T>:
         RingBufferIterator::new(self)
     }
 
+    /// Extends the ringbuffer with elements from a slice.
+    fn extend_from_slice(&mut self, elements: &[T])
+    where
+        T: Clone,
+    {
+        // Default implementation.
+        // For performance reasons, specific RingBuffers should use an optimized implementation.
+        for element in elements {
+            let _ = self.enqueue(element.clone());
+        }
+    }
+
     /// Converts the buffer to a vector. This Copies all elements in the ringbuffer.
     #[cfg(feature = "alloc")]
     fn to_vec(&self) -> Vec<T>

src/with_alloc/alloc_ringbuffer.rs

@@ -474,4 +474,12 @@ mod tests {
         assert_eq!(buf.capacity, 4);
         assert_eq!(buf.to_vec(), alloc::vec![1, 2, 3, 4]);
     }
+
+    #[test]
+    fn test_extend_from_slice() {
+        let mut buf = AllocRingBuffer::new(3);
+        let elems = [1, 2, 3];
+        buf.extend_from_slice(&elems);
+        assert_eq!(buf.to_vec().as_slice(), elems)
+    }
 }

src/with_alloc/vecdeque.rs

@@ -282,3 +282,16 @@ impl<T> FromIterator<T> for GrowableAllocRingBuffer<T> {
         Self(VecDeque::from_iter(iter))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extend_from_slice() {
+        let mut buf = GrowableAllocRingBuffer::new();
+        let elems = [1, 2, 3];
+        buf.extend_from_slice(&elems);
+        assert_eq!(buf.to_vec().as_slice(), elems)
+    }
+}

src/with_const_generics.rs

@@ -496,4 +496,12 @@ mod tests {
             vec![1, 2, 3]
         );
     }
+
+    #[test]
+    fn test_extend_from_slice() {
+        let mut buf = ConstGenericRingBuffer::<i32, 3>::new();
+        let elems = [1, 2, 3];
+        buf.extend_from_slice(&elems);
+        assert_eq!(buf.to_vec().as_slice(), elems);
+    }
 }