!again

Author: Hywan

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

@@ -160,6 +160,15 @@ pub mod experimental {
             self.chunks.iter_chunks_from(position)
         }
 
+        /// Iterate over the chunks, starting from `position`, backward — i.e.
+        /// to the latest chunk.
+        pub fn iter_chunks_backward_from<'a>(
+            &'a self,
+            position: ChunkPosition,
+        ) -> Result<LinkedChunkIterBackward<'a, Event, CHUNK_CAPACITY>, LinkedChunkError> {
+            self.chunks.iter_chunks_backward_from(position)
+        }
+
         /// Iterate over the events.
         ///
         /// The most recent event comes first.
@@ -174,6 +183,15 @@ pub mod experimental {
         ) -> Result<impl Iterator<Item = (ItemPosition, &'a Event)>, LinkedChunkError> {
             self.chunks.iter_items_from(position)
         }
+
+        /// Iterate over the events, starting from `position`, backward — i.e.
+        /// to the latest event.
+        pub fn iter_events_backward_from<'a>(
+            &'a self,
+            position: ItemPosition,
+        ) -> Result<impl Iterator<Item = (ItemPosition, &'a Event)>, LinkedChunkError> {
+            self.chunks.iter_items_backward_from(position)
+        }
     }
 
     #[derive(Debug)]
@@ -298,6 +316,10 @@ pub mod experimental {
             Ok(())
         }
 
+        /// Insert a gap at a specified position in the [`LinkedChunk`].
+        ///
+        /// Because the `position` can be invalid, this method returns a
+        /// `Result`.
         fn insert_gap_at(&mut self, position: ItemPosition) -> Result<(), LinkedChunkError> {
             let chunk_index = position.chunk_index();
             let item_index = position.item_index();
@@ -414,14 +436,31 @@ pub mod experimental {
             ))
         }
 
+        /// Iterate over the chunks, starting from `position`, backward.
+        ///
+        /// It iterates from the chunk at `position` to the last chunk.
+        fn iter_chunks_backward_from<'a>(
+            &'a self,
+            position: ChunkPosition,
+        ) -> Result<LinkedChunkIterBackward<'a, T, C>, LinkedChunkError> {
+            Ok(LinkedChunkIterBackward::new(
+                self.nth_chunk(position)
+                    .ok_or(LinkedChunkError::InvalidChunkIndex { index: position })?,
+                position,
+            ))
+        }
+
         /// Iterate over the items.
         ///
-        /// It iterates from the last the first item.
+        /// It iterates from the last to the first item.
         fn iter_items<'a>(&'a self) -> impl Iterator<Item = (ItemPosition, &'a T)> {
             self.iter_items_from(ItemPosition(0, 0))
                 .expect("`iter_items_from` cannot fail because at least one empty chunk must exist")
         }
 
+        /// Iterate over the items, starting from `position`.
+        ///
+        /// It iterates from the item at `position` to the first item.
         fn iter_items_from<'a>(
             &'a self,
             position: ItemPosition,
@@ -439,6 +478,26 @@ pub mod experimental {
                 .flatten()
                 .skip(position.item_index()))
         }
+
+        /// Iterate over the items, stargin from `position`, backward.
+        ///
+        /// It iterates from the item at `position` to the last item.
+        fn iter_items_backward_from<'a>(
+            &'a self,
+            position: ItemPosition,
+        ) -> Result<impl Iterator<Item = (ItemPosition, &'a T)>, LinkedChunkError> {
+            Ok(self
+                .iter_chunks_backward_from(position.chunk_index())?
+                .filter_map(|(chunk_index, chunk)| match &chunk.content {
+                    ChunkContent::Gap => None,
+                    ChunkContent::Items(items) => {
+                        Some(items.iter().rev().enumerate().rev().map(move |(item_index, item)| {
+                            (ItemPosition(chunk_index, item_index), item)
+                        }))
+                    }
+                })
+                .flatten())
+        }
     }
 
     /// The position of a chunk in a [`LinkedChunk`].
@@ -465,7 +524,8 @@ pub mod experimental {
         }
     }
 
-    /// An iterator over a [`LinkedChunk`].
+    /// An iterator over a [`LinkedChunk`] that traverses the chunk in forward
+    /// direction (i.e. it call `previous` on each chunk to make progress).
     pub struct LinkedChunkIter<'a, T, const CHUNK_CAPACITY: usize> {
         chunk: Option<&'a Chunk<T, CHUNK_CAPACITY>>,
         position: ChunkPosition,
@@ -495,6 +555,37 @@ pub mod experimental {
         }
     }
 
+    /// An iterator over a [`LinkedChunk`] that traverses the chunk in backward
+    /// direction (i.e. it call `next` on each chunk to make progress).
+    pub struct LinkedChunkIterBackward<'a, T, const CHUNK_CAPACITY: usize> {
+        chunk: Option<&'a Chunk<T, CHUNK_CAPACITY>>,
+        position: ChunkPosition,
+    }
+
+    impl<'a, T, const C: usize> LinkedChunkIterBackward<'a, T, C> {
+        /// Create a new [`LinkedChunkIter`] from a particular [`Chunk`].
+        fn new(from_chunk: &'a Chunk<T, C>, position: ChunkPosition) -> Self {
+            Self { chunk: Some(from_chunk), position }
+        }
+    }
+
+    impl<'a, T, const C: usize> Iterator for LinkedChunkIterBackward<'a, T, C> {
+        type Item = (ChunkPosition, &'a Chunk<T, C>);
+
+        fn next(&mut self) -> Option<Self::Item> {
+            let Some(chunk) = self.chunk else {
+                return None;
+            };
+
+            let position = self.position;
+
+            self.chunk = chunk.next();
+            self.position = self.position.saturating_sub(1);
+
+            Some((position, chunk))
+        }
+    }
+
     /// This enum represents the content of a [`Chunk`].
     #[derive(Debug)]
     pub enum ChunkContent<T> {
@@ -886,6 +977,7 @@ pub mod experimental {
                 }
             );
             assert_matches!(iterator.next(), Some((2, Chunk { content: ChunkContent::Gap, .. })));
+            //                                     ^ it increases!
             assert_matches!(
                 iterator.next(),
                 Some((3, Chunk { content: ChunkContent::Items(items), .. })) => {
@@ -897,6 +989,36 @@ pub mod experimental {
             Ok(())
         }
 
+        #[test]
+        fn test_iter_chunks_backward_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_chunks_backward_from(
+                events.event_position(|event| *event == 'c').unwrap().chunk_index(),
+            )?;
+
+            assert_matches!(
+                iterator.next(),
+                Some((1, Chunk { content: ChunkContent::Items(items), .. })) => {
+                //    ^ it does not start at 0!
+                    assert_eq!(items, &['c', 'd']);
+                }
+            );
+            assert_matches!(
+                iterator.next(),
+                Some((0, Chunk { content: ChunkContent::Items(items), .. })) => {
+                //    ^ it decreases!
+                    assert_eq!(items, &['e']);
+                }
+            );
+            assert_matches!(iterator.next(), None);
+
+            Ok(())
+        }
+
         #[test]
         fn test_iter_items() {
             let mut events = Events::<char, 2>::new();
@@ -932,6 +1054,24 @@ pub mod experimental {
             Ok(())
         }
 
+        #[test]
+        fn test_iter_items_backward_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_backward_from(events.event_position(|event| *event == 'c').unwrap())?;
+
+            assert_matches!(iterator.next(), Some((ItemPosition(1, 1), 'c')));
+            assert_matches!(iterator.next(), Some((ItemPosition(1, 0), 'd')));
+            assert_matches!(iterator.next(), Some((ItemPosition(0, 0), 'e')));
+            assert_matches!(iterator.next(), None);
+
+            Ok(())
+        }
+
         #[test]
         fn test_insert_items_at() -> Result<(), LinkedChunkError> {
             let mut events = Events::<char, 3>::new();