!fourth

Author: Hywan

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

@@ -124,6 +124,7 @@ pub mod experimental {
             self.chunks.insert_items_at(events.into_iter(), position)
         }
 
+        /// Insert a gap at a specified position.
         pub fn insert_gap_at(&mut self, position: ItemPosition) -> Result<(), LinkedChunkError> {
             self.chunks.insert_gap_at(position)
         }
@@ -151,6 +152,14 @@ pub mod experimental {
             self.chunks.iter_chunks()
         }
 
+        /// Iterate over the chunks, starting from `position`.
+        pub fn iter_chunks_from<'a>(
+            &'a self,
+            position: ChunkPosition,
+        ) -> Result<LinkedChunkIter<'a, Event, CHUNK_CAPACITY>, LinkedChunkError> {
+            self.chunks.iter_chunks_from(position)
+        }
+
         /// Iterate over the events.
         ///
         /// The most recent event comes first.
@@ -332,9 +341,19 @@ pub mod experimental {
             Ok(())
         }
 
+        /// Get the nth chunk as a reference, if it exists.
+        fn nth_chunk<'a>(&'a self, nth: ChunkPosition) -> Option<&'a Chunk<T, C>> {
+            let mut chunk =
+                self.last.or(Some(self.first)).as_ref().map(|chunk| unsafe { chunk.as_ref() });
+
+            for _ in 0..nth {
+                chunk = chunk?.previous();
+            }
+
+            chunk
+        }
+
         /// Get the nth chunk as a mutable reference, if it exists.
-        ///
-        /// 0 represents the last chunk.
         fn nth_chunk_mut<'a>(&'a mut self, nth: ChunkPosition) -> Option<&'a mut Chunk<T, C>> {
             let mut chunk =
                 self.last.or(Some(self.first)).as_mut().map(|chunk| unsafe { chunk.as_mut() });
@@ -368,7 +387,22 @@ pub mod experimental {
         ///
         /// It iterates from the last to the first chunk.
         fn iter_chunks<'a>(&'a self) -> LinkedChunkIter<'a, T, C> {
-            LinkedChunkIter::new(unsafe { self.last.unwrap_or(self.first).as_ref() })
+            self.iter_chunks_from(0)
+                .expect("`iter_chunks_from` cannot fail because at least one chunk must exist")
+        }
+
+        /// Iterate over the chunks, starting from `position`.
+        ///
+        /// It iterates from the chunk at `position` to the first chunk.
+        fn iter_chunks_from<'a>(
+            &'a self,
+            position: ChunkPosition,
+        ) -> Result<LinkedChunkIter<'a, T, C>, LinkedChunkError> {
+            Ok(LinkedChunkIter::new(
+                self.nth_chunk(position)
+                    .ok_or(LinkedChunkError::InvalidChunkIndex { index: position })?,
+                position,
+            ))
         }
 
         /// Iterate over the items.
@@ -389,9 +423,14 @@ pub mod experimental {
     }
 
     /// The position of a chunk in a [`LinkedChunk`].
+    ///
+    /// 0 represents the latest chunk.
     type ChunkPosition = usize;
 
     /// The position of an item in a [`LinkedChunk`].
+    ///
+    /// It's a pair of a chunk position and an item index. `(…, 0)` represents
+    /// the last item in the chunk.
     #[derive(Debug, PartialEq)]
     pub struct ItemPosition(ChunkPosition, usize);
 
@@ -410,13 +449,13 @@ pub mod experimental {
     /// An iterator over a [`LinkedChunk`].
     pub struct LinkedChunkIter<'a, T, const CHUNK_CAPACITY: usize> {
         chunk: Option<&'a Chunk<T, CHUNK_CAPACITY>>,
-        position: usize,
+        position: ChunkPosition,
     }
 
     impl<'a, T, const C: usize> LinkedChunkIter<'a, T, C> {
         /// Create a new [`LinkedChunkIter`] from a particular [`Chunk`].
-        fn new(from_chunk: &'a Chunk<T, C>) -> Self {
-            Self { chunk: Some(from_chunk), position: 0 }
+        fn new(from_chunk: &'a Chunk<T, C>, position: ChunkPosition) -> Self {
+            Self { chunk: Some(from_chunk), position }
         }
     }
 
@@ -439,7 +478,7 @@ pub mod experimental {
 
     /// This enum represents the content of a [`Chunk`].
     #[derive(Debug)]
-    enum ChunkContent<T> {
+    pub enum ChunkContent<T> {
         /// The chunk represents a gap in the linked chunk, i.e. a hole. It
         /// means that some items are missing in this location.
         Gap,
@@ -672,7 +711,7 @@ pub mod experimental {
     mod tests {
         use assert_matches::assert_matches;
 
-        use super::{Events, ItemPosition, LinkedChunkError};
+        use super::{Chunk, ChunkContent, Events, ItemPosition, LinkedChunkError};
 
         macro_rules! assert_events_eq {
             ( @_ [ $iterator:ident, $chunk_index:ident, $event_index:ident ] { [-] $( $rest:tt )* } { $( $accumulator:tt )* } ) => {
@@ -778,6 +817,67 @@ pub mod experimental {
             assert_eq!(events.event_position(|event| *event == 'e'), Some(ItemPosition(3, 1)));
         }
 
+        #[test]
+        fn test_iter_chunks() {
+            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();
+
+            assert_matches!(
+                iterator.next(),
+                Some((0, Chunk { content: ChunkContent::Items(items), .. })) => {
+                    assert_eq!(items, &['e']);
+                }
+            );
+            assert_matches!(
+                iterator.next(),
+                Some((1, Chunk { content: ChunkContent::Items(items), .. })) => {
+                    assert_eq!(items, &['c', 'd']);
+                }
+            );
+            assert_matches!(iterator.next(), Some((2, Chunk { content: ChunkContent::Gap, .. })));
+            assert_matches!(
+                iterator.next(),
+                Some((3, Chunk { content: ChunkContent::Items(items), .. })) => {
+                    assert_eq!(items, &['a', 'b']);
+                }
+            );
+            assert_matches!(iterator.next(), None);
+        }
+
+        #[test]
+        fn test_iter_chunks_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_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((2, Chunk { content: ChunkContent::Gap, .. })));
+            assert_matches!(
+                iterator.next(),
+                Some((3, Chunk { content: ChunkContent::Items(items), .. })) => {
+                    assert_eq!(items, &['a', 'b']);
+                }
+            );
+            assert_matches!(iterator.next(), None);
+
+            Ok(())
+        }
+
         #[test]
         fn test_insert_items_at() -> Result<(), LinkedChunkError> {
             let mut events = Events::<char, 3>::new();
@@ -820,6 +920,7 @@ pub mod experimental {
                     events.iter_events(),
                     ['f'] ['e', 'z', 'y'] ['x', 'w', 'd'] ['c', 's', 'r'] ['b', 'a', 'o'] ['n', 'm', 'l']
                 );
+                assert_eq!(events.len(), 16);
             }
 
             // Insert in a chunk that does not exist.
@@ -853,6 +954,8 @@ pub mod experimental {
                 );
             }
 
+            assert_eq!(events.len(), 16);
+
             Ok(())
         }
 
@@ -905,6 +1008,8 @@ pub mod experimental {
                 );
             }
 
+            assert_eq!(events.len(), 6);
+
             Ok(())
         }
     }