!again

Author: Hywan

crates/matrix-sdk/src/event_cache/store.rs

@@ -166,6 +166,14 @@ pub mod experimental {
         pub fn iter_events<'a>(&'a self) -> impl Iterator<Item = (ItemPosition, &'a Event)> {
             self.chunks.iter_items()
         }
+
+        /// Iterate over the events, starting from `position`.
+        pub fn iter_events_from<'a>(
+            &'a self,
+            position: ItemPosition,
+        ) -> Result<impl Iterator<Item = (ItemPosition, &'a Event)>, LinkedChunkError> {
+            self.chunks.iter_items_from(position)
+        }
     }
 
     #[derive(Debug)]
@@ -387,8 +395,9 @@ pub mod experimental {
         ///
         /// It iterates from the last to the first chunk.
         fn iter_chunks<'a>(&'a self) -> LinkedChunkIter<'a, T, C> {
-            self.iter_chunks_from(0)
-                .expect("`iter_chunks_from` cannot fail because at least one chunk must exist")
+            self.iter_chunks_from(0).expect(
+                "`iter_chunks_from` cannot fail because at least one empty chunk must exist",
+            )
         }
 
         /// Iterate over the chunks, starting from `position`.
@@ -409,7 +418,16 @@ pub mod experimental {
         ///
         /// It iterates from the last the first item.
         fn iter_items<'a>(&'a self) -> impl Iterator<Item = (ItemPosition, &'a T)> {
-            self.iter_chunks()
+            self.iter_items_from(ItemPosition(0, 0))
+                .expect("`iter_items_from` cannot fail because at least one empty chunk must exist")
+        }
+
+        fn iter_items_from<'a>(
+            &'a self,
+            position: ItemPosition,
+        ) -> Result<impl Iterator<Item = (ItemPosition, &'a T)>, LinkedChunkError> {
+            Ok(self
+                .iter_chunks_from(position.chunk_index())?
                 .filter_map(|(chunk_index, chunk)| match &chunk.content {
                     ChunkContent::Gap => None,
                     ChunkContent::Items(items) => {
@@ -419,6 +437,7 @@ pub mod experimental {
                     }
                 })
                 .flatten()
+                .skip(position.item_index()))
         }
     }
 
@@ -878,6 +897,41 @@ pub mod experimental {
             Ok(())
         }
 
+        #[test]
+        fn test_iter_items() {
+            let mut events = Events::<char, 2>::new();
+            events.push_events(['a', 'b']);
+            events.push_gap();
+            events.push_events(['c', 'd', 'e']);
+
+            let mut iterator = events.iter_events();
+
+            assert_matches!(iterator.next(), Some((ItemPosition(0, 0), 'e')));
+            assert_matches!(iterator.next(), Some((ItemPosition(1, 0), 'd')));
+            assert_matches!(iterator.next(), Some((ItemPosition(1, 1), 'c')));
+            assert_matches!(iterator.next(), Some((ItemPosition(3, 0), 'b')));
+            assert_matches!(iterator.next(), Some((ItemPosition(3, 1), 'a')));
+            assert_matches!(iterator.next(), None);
+        }
+
+        #[test]
+        fn test_iter_items_from() -> Result<(), LinkedChunkError> {
+            let mut events = Events::<char, 2>::new();
+            events.push_events(['a', 'b']);
+            events.push_gap();
+            events.push_events(['c', 'd', 'e']);
+
+            let mut iterator =
+                events.iter_events_from(events.event_position(|event| *event == 'c').unwrap())?;
+
+            assert_matches!(iterator.next(), Some((ItemPosition(1, 1), 'c')));
+            assert_matches!(iterator.next(), Some((ItemPosition(3, 0), 'b')));
+            assert_matches!(iterator.next(), Some((ItemPosition(3, 1), 'a')));
+            assert_matches!(iterator.next(), None);
+
+            Ok(())
+        }
+
         #[test]
         fn test_insert_items_at() -> Result<(), LinkedChunkError> {
             let mut events = Events::<char, 3>::new();