From 43fe7aca33274c2b753283005956b05d563926f5 Mon Sep 17 00:00:00 2001
From: Chris Mikkelson <cmikk@fsi.io>
Date: Sun, 28 Apr 2024 15:46:14 -0500
Subject: [PATCH] SeekableVec: add value type.

---
 src/seekable/vec.rs | 34 +++++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/src/seekable/vec.rs b/src/seekable/vec.rs
index 17e7559..9acb9df 100644
--- a/src/seekable/vec.rs
+++ b/src/seekable/vec.rs
@@ -2,42 +2,50 @@ use crate::seekable::Iter;
 use crate::Seekable;
 
 #[derive(Debug)]
-pub struct SeekableVec<T: Ord + Copy> {
+pub struct SeekableVec<K: Ord + Copy, V: Ord + Copy> {
     off: usize,
-    v: Vec<T>,
+    v: Vec<(K, V)>,
 }
-impl<T: Ord + Copy> IntoIterator for SeekableVec<T> {
-    type Item = (T, ());
+impl<K: Ord + Copy, V: Ord + Copy> IntoIterator for SeekableVec<K, V> {
+    type Item = (K, V);
     type IntoIter = Iter<Self>;
     fn into_iter(self) -> Iter<Self> {
         Iter(self)
     }
 }
-impl<T: Ord + Copy> Seekable for SeekableVec<T> {
-    type Key = T;
-    type Value = ();
-    fn next(&mut self) -> Option<(T, ())> {
+impl<K: Ord + Copy, V: Ord + Copy> Seekable for SeekableVec<K, V> {
+    type Key = K;
+    type Value = V;
+    fn next(&mut self) -> Option<(K, V)> {
         if self.off >= self.v.len() {
             return None;
         }
         let v = self.v[self.off];
         self.off += 1;
-        Some((v, ()))
+        Some(v)
     }
-    fn seek(&mut self, key: &T) {
+    fn seek(&mut self, key: &K) {
         self.off = 0;
         while self.off < self.v.len() {
-            if self.v[self.off] >= *key {
+            if self.v[self.off].0 >= *key {
                 break;
             }
             self.off += 1;
         }
     }
 }
-impl<T: Ord + Copy> From<Vec<T>> for SeekableVec<T> {
-    fn from(vec: Vec<T>) -> SeekableVec<T> {
+impl<K: Ord + Copy, V: Ord + Copy> From<Vec<(K, V)>> for SeekableVec<K, V> {
+    fn from(vec: Vec<(K, V)>) -> SeekableVec<K, V> {
         let mut sv = SeekableVec { off: 0, v: vec };
         sv.v.sort();
         sv
     }
 }
+
+impl<K: Ord + Copy> From<Vec<K>> for SeekableVec<K, ()> {
+    fn from(vec: Vec<K>) -> SeekableVec<K, ()> {
+        let mut pv = vec.into_iter().map(|k| (k, ())).collect::<Vec<(K, ())>>();
+        pv.sort();
+        SeekableVec { off: 0, v: pv }
+    }
+}
-- 
2.50.1