ringbuffer_trait: add extend_from_slice

This adds an extend_from_slice function to the RingBuffer trait. The default
implementation calls push() for each element. However, by creating specialized
implementations for the various buffers, one can do various performance
optimizations in a follow-up.

Author: phip1611

src/ringbuffer_trait.rs

@@ -230,6 +230,15 @@ 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 {
+            self.push(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

@@ -469,4 +469,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

@@ -280,3 +280,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

@@ -492,5 +492,13 @@ 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)
+        }
     }
 }