Merge pull request #23 from ing-systems/fix/iter-proper-elem-cache

Fix element caching at iterating

Author: khrs

src/lib.rs

@@ -515,41 +515,38 @@ impl QueueFile {
             return;
         }
 
-        let need_to_cache = self.offset_cache_kind.map_or(false, |kind| {
-            let last_index = self.elem_cnt - 1;
+        self.cache_elem_if_needed(self.elem_cnt - 1, self.last, affected_items);
+    }
 
-            match kind {
-                OffsetCacheKind::Linear { offset } => {
-                    let last_cached_index = self.cached_offsets.back().map_or(0, |(idx, _)| *idx);
-                    last_index - last_cached_index >= offset
-                }
-                OffsetCacheKind::Quadratic => {
-                    let x = (last_index as f64).sqrt() as usize;
-                    x > 1 && (self.elem_cnt - affected_items..=last_index).contains(&(x * x))
-                }
+    fn cache_elem_if_needed(&mut self, index: usize, elem: Element, affected_items: usize) {
+        debug_assert!(index <= self.elem_cnt);
+        debug_assert!(index + 1 >= affected_items);
+
+        let need_to_cache = self.offset_cache_kind.map_or(false, |kind| match kind {
+            OffsetCacheKind::Linear { offset } => {
+                let last_cached_index = self.cached_offsets.back().map_or(0, |(idx, _)| *idx);
+                index.saturating_sub(last_cached_index) >= offset
+            }
+            OffsetCacheKind::Quadratic => {
+                let x = (index as f64).sqrt() as usize;
+                x > 1 && (index + 1 - affected_items..=index).contains(&(x * x))
             }
         });
 
         if need_to_cache {
-            self.cache_last_offset();
-        }
-    }
-
-    fn cache_last_offset(&mut self) {
-        debug_assert!(self.elem_cnt != 0);
-
-        let index = self.elem_cnt - 1;
-
-        if let Some((last_cached_index, last_cached_elem)) = self.cached_offsets.back() {
-            if *last_cached_index == index {
-                debug_assert_eq!(last_cached_elem.pos, self.last.pos);
-                debug_assert_eq!(last_cached_elem.len, self.last.len);
+            if let Some((last_cached_index, last_cached_elem)) = self.cached_offsets.back() {
+                if *last_cached_index >= index {
+                    if *last_cached_index == index {
+                        debug_assert_eq!(last_cached_elem.pos, elem.pos);
+                        debug_assert_eq!(last_cached_elem.len, elem.len);
+                    }
 
-                return;
+                    return;
+                }
             }
-        }
 
-        self.cached_offsets.push_back((index, self.last));
+            self.cached_offsets.push_back((index, elem));
+        }
     }
 
     #[inline]
@@ -1270,7 +1267,7 @@ impl<'a> Iterator for Iter<'a> {
         };
 
         for _ in 0..left {
-            self.next();
+            self.borrowed_next();
         }
 
         self.next()
@@ -1297,9 +1294,9 @@ impl Iter<'_> {
         self.next_elem_pos = self
             .queue_file
             .wrap_pos(current.pos + Element::HEADER_LENGTH as u64 + current.len as u64);
-        self.next_elem_index += 1;
 
-        self.queue_file.cache_last_offset_if_needed(1);
+        self.queue_file.cache_elem_if_needed(self.next_elem_index, current, 1);
+        self.next_elem_index += 1;
 
         Some(&self.buffer[..current.len])
     }