Add and implement get_range.

src/ringbuffer_trait.rs

@@ -1,4 +1,4 @@
-use core::ops::{Index, IndexMut};
+use core::ops::{Index, IndexMut, Range};
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -170,6 +170,11 @@ pub unsafe trait RingBuffer<T>:
         unsafe { Self::ptr_get_mut(self, index).map(|i| &mut *i) }
     }
 
+    /// Gets values relative to the current index. 0 is the next index to be written to with push.
+    fn get_range<'a>(&'a self, range: Range<usize>) -> impl Iterator<Item = &'a T>
+    where
+        T: 'a;
+
     /// same as [`get_mut`](RingBuffer::get_mut) but on raw pointers.
     ///
     /// # Safety

src/with_alloc/alloc_ringbuffer.rs

@@ -1,4 +1,5 @@
-use core::ops::{Index, IndexMut};
+use alloc::slice;
+use core::ops::{Index, IndexMut, Range};
 
 use crate::ringbuffer_trait::{
     RingBuffer, RingBufferIntoIterator, RingBufferIterator, RingBufferMutIterator,
@@ -292,6 +293,22 @@ unsafe impl<T> RingBuffer<T> for AllocRingBuffer<T> {
             unsafe { ptr::write(get_unchecked_mut(self, i), f()) };
         }
     }
+
+    #[inline]
+    fn get_range<'a>(&'a self, range: Range<usize>) -> impl Iterator<Item = &'a T>
+    where
+        T: 'a,
+    {
+        let normalized_index = self.readptr + range.start.rem_euclid(self.len());
+        let index = normalized_index % self.buffer_size();
+        let buf = unsafe { slice::from_raw_parts(self.buf, self.buffer_size()) };
+        buf[index..]
+            .iter()
+            .chain(buf[..index].iter())
+            .take(self.len())
+            .cycle()
+            .take(range.len())
+    }
 }
 
 impl<T> AllocRingBuffer<T> {

src/with_alloc/vecdeque.rs

@@ -1,7 +1,7 @@
 use crate::ringbuffer_trait::{RingBufferIntoIterator, RingBufferIterator, RingBufferMutIterator};
 use crate::{AllocRingBuffer, RingBuffer};
 use alloc::collections::VecDeque;
-use core::ops::{Deref, DerefMut, Index, IndexMut};
+use core::ops::{Deref, DerefMut, Index, IndexMut, Range};
 
 /// A growable ringbuffer. Once capacity is reached, the size is doubled.
 /// Wrapper of the built-in [`VecDeque`] struct.
@@ -255,6 +255,18 @@ unsafe impl<T> RingBuffer<T> for GrowableAllocRingBuffer<T> {
         }
         .map(|i| i as *mut T)
     }
+
+    /// Gets values relative to the current index. 0 is the next index to be written to with push.
+    ///
+    /// # Panics
+    /// Panics if the starting point is greater than the end point
+    /// or if the end point is greater than the length of the deque.
+    fn get_range<'a>(&'a self, range: Range<usize>) -> impl Iterator<Item = &'a T>
+    where
+        T: 'a,
+    {
+        self.0.range(range)
+    }
 }
 
 impl<T> Extend<T> for GrowableAllocRingBuffer<T> {

src/with_const_generics.rs

@@ -3,7 +3,7 @@ use crate::RingBuffer;
 use core::iter::FromIterator;
 use core::mem;
 use core::mem::MaybeUninit;
-use core::ops::{Index, IndexMut};
+use core::ops::{Index, IndexMut, Range};
 
 /// The `ConstGenericRingBuffer` struct is a `RingBuffer` implementation which does not require `alloc` but
 /// uses const generics instead.
@@ -321,6 +321,22 @@ unsafe impl<T, const CAP: usize> RingBuffer<T> for ConstGenericRingBuffer<T, CAP
         self.writeptr = CAP;
         self.buf.fill_with(|| MaybeUninit::new(f()));
     }
+
+    #[inline]
+    fn get_range<'a>(&'a self, range: Range<usize>) -> impl Iterator<Item = &'a T>
+    where
+        T: 'a,
+    {
+        let normalized_index = self.readptr + range.start.rem_euclid(self.len());
+        let index = normalized_index % self.buffer_size();
+        self.buf[index..]
+            .iter()
+            .chain(self.buf[..index].iter())
+            .take(self.len())
+            .map(|x| unsafe { x.assume_init_ref() })
+            .cycle()
+            .take(range.len())
+    }
 }
 
 impl<T, const CAP: usize> Default for ConstGenericRingBuffer<T, CAP> {