From 9f2f4167b178110b22d114073e9bb65de2740d92 Mon Sep 17 00:00:00 2001
From: Matt Schulte <schultetwin1@gmail.com>
Date: Wed, 29 Mar 2023 00:49:00 -0700
Subject: [PATCH 1/3] Add ordered_get() to HistoryBuffer

This allows users to get access to the elements of the history buffer
in historical order.

# Conflicts:
#	src/histbuf.rs
---
 src/histbuf.rs | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/src/histbuf.rs b/src/histbuf.rs
index cc4b4922ef..bb57eaa1ed 100644
--- a/src/histbuf.rs
+++ b/src/histbuf.rs
@@ -504,6 +504,41 @@ impl<T, S: HistBufStorage<T> + ?Sized> HistoryBufferInner<T, S> {
         }
     }
 
+    /// Returns a reference to the element in the order from oldest to newest
+    ///
+    /// `buf.ordered_get(0)` will always return the oldest element in the buffer
+    ///
+    /// `buf.ordered_get(buf.len() - 1)` will always return the newest element
+    /// in the buffer
+    ///
+    /// Returns None if `index >= self.len()`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use heapless::HistoryBuffer;
+    ///
+    /// let mut buffer: HistoryBuffer<u8, 6> = HistoryBuffer::new();
+    /// buffer.extend([0, 0, 0]);
+    /// buffer.extend([1, 2, 3, 4, 5, 6]);
+    /// assert_eq!(buffer.ordered_get(0), Some(&1u8));
+    /// assert_eq!(buffer.ordered_get(1), Some(&2u8));
+    /// assert_eq!(buffer.ordered_get(2), Some(&3u8));
+    /// assert_eq!(buffer.ordered_get(6), None);
+    /// ```
+    pub fn ordered_get(&self, idx: usize) -> Option<&T> {
+        if self.len() <= idx {
+            None
+        } else {
+            let (front, back) = self.as_slices();
+            if idx < front.len() {
+                Some(&front[idx])
+            } else {
+                Some(&back[idx - front.len()])
+            }
+        }
+    }
+
     /// Returns double ended iterator for iterating over the buffer from
     /// the oldest to the newest and back.
     ///
@@ -855,6 +890,24 @@ mod tests {
         }
     }
 
+    #[test]
+    fn ordered_get() {
+        let mut buffer: HistoryBuffer<u8, 6> = HistoryBuffer::new();
+        assert_eq!(buffer.ordered_get(0), None);
+
+        buffer.write(1u8);
+        assert_eq!(buffer.ordered_get(0), Some(&1u8));
+
+        buffer.write(2u8);
+        assert_eq!(buffer.ordered_get(0), Some(&1u8));
+        assert_eq!(buffer.ordered_get(1), Some(&2u8));
+
+        buffer.extend([3, 4, 5, 6, 7, 8]);
+        assert_eq!(buffer.ordered_get(0), Some(&3u8));
+        assert_eq!(buffer.ordered_get(5), Some(&8u8));
+        assert_eq!(buffer.ordered_get(6), None);
+    }
+
     #[test]
     fn ordered() {
         // test on an empty buffer

From 2f0008b4cace4fe0e931d736c58c28b6d6e16ec6 Mon Sep 17 00:00:00 2001
From: Markus Reiter <me@reitermark.us>
Date: Sun, 6 Apr 2025 16:04:30 +0200
Subject: [PATCH 2/3] Fix formatting.

---
 src/histbuf.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/histbuf.rs b/src/histbuf.rs
index bb57eaa1ed..2a7dab6b1e 100644
--- a/src/histbuf.rs
+++ b/src/histbuf.rs
@@ -504,14 +504,14 @@ impl<T, S: HistBufStorage<T> + ?Sized> HistoryBufferInner<T, S> {
         }
     }
 
-    /// Returns a reference to the element in the order from oldest to newest
+    /// Returns a reference to the element in the order from oldest to newest.
     ///
-    /// `buf.ordered_get(0)` will always return the oldest element in the buffer
+    /// `buf.ordered_get(0)` will always return the oldest element in the buffer.
     ///
     /// `buf.ordered_get(buf.len() - 1)` will always return the newest element
-    /// in the buffer
+    /// in the buffer.
     ///
-    /// Returns None if `index >= self.len()`
+    /// Returns None if `index >= self.len()`.
     ///
     /// # Examples
     ///

From a7955022887973204db5c168b204e8cf328d4464 Mon Sep 17 00:00:00 2001
From: Markus Reiter <me@reitermark.us>
Date: Sun, 6 Apr 2025 17:55:22 +0200
Subject: [PATCH 3/3] Simplify implementation of `ordered_get`.

---
 src/histbuf.rs | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/histbuf.rs b/src/histbuf.rs
index 2a7dab6b1e..68ddf58a98 100644
--- a/src/histbuf.rs
+++ b/src/histbuf.rs
@@ -527,16 +527,7 @@ impl<T, S: HistBufStorage<T> + ?Sized> HistoryBufferInner<T, S> {
     /// assert_eq!(buffer.ordered_get(6), None);
     /// ```
     pub fn ordered_get(&self, idx: usize) -> Option<&T> {
-        if self.len() <= idx {
-            None
-        } else {
-            let (front, back) = self.as_slices();
-            if idx < front.len() {
-                Some(&front[idx])
-            } else {
-                Some(&back[idx - front.len()])
-            }
-        }
+        self.oldest_ordered().nth(idx)
     }
 
     /// Returns double ended iterator for iterating over the buffer from