refactor(event cache): get rid of a few generics

The YAGNI crew strikes again.

Author: bnjbvr

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

@@ -61,14 +61,11 @@ impl Deduplicator {
     /// Find duplicates in the given collection of events, and return both
     /// valid events (those with an event id) as well as the event ids of
     /// duplicate events.
-    pub async fn filter_duplicate_events<I>(
+    pub async fn filter_duplicate_events(
         &self,
-        events: I,
+        events: Vec<Event>,
         room_events: &RoomEvents,
-    ) -> Result<(Vec<Event>, Vec<OwnedEventId>), EventCacheError>
-    where
-        I: Iterator<Item = Event>,
-    {
+    ) -> Result<(Vec<Event>, Vec<OwnedEventId>), EventCacheError> {
         match self {
             Deduplicator::InMemory(dedup) => Ok(dedup.filter_duplicate_events(events, room_events)),
             Deduplicator::PersistentStore(dedup) => dedup.filter_duplicate_events(events).await,
@@ -89,28 +86,24 @@ pub struct StoreDeduplicator {
 }
 
 impl StoreDeduplicator {
-    async fn filter_duplicate_events<I>(
+    async fn filter_duplicate_events(
         &self,
-        events: I,
-    ) -> Result<(Vec<Event>, Vec<OwnedEventId>), EventCacheError>
-    where
-        I: Iterator<Item = Event>,
-    {
+        mut events: Vec<Event>,
+    ) -> Result<(Vec<Event>, Vec<OwnedEventId>), EventCacheError> {
         let store = self.store.lock().await?;
 
         // Collect event ids as we "validate" events (i.e. check they have a valid event
         // id.)
         let mut event_ids = Vec::new();
-        let events = events
-            .filter_map(|event| {
-                if let Some(event_id) = event.event_id() {
-                    event_ids.push(event_id);
-                    Some(event)
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
+
+        events.retain(|event| {
+            if let Some(event_id) = event.event_id() {
+                event_ids.push(event_id);
+                true
+            } else {
+                false
+            }
+        });
 
         // Let the store do its magic ✨
         let duplicates = store.filter_duplicated_events(&self.room_id, event_ids).await?;
@@ -157,18 +150,15 @@ impl BloomFilterDeduplicator {
     /// Find duplicates in the given collection of events, and return both
     /// valid events (those with an event id) as well as the event ids of
     /// duplicate events.
-    fn filter_duplicate_events<'a, I>(
-        &'a self,
-        events: I,
-        room_events: &'a RoomEvents,
-    ) -> (Vec<Event>, Vec<OwnedEventId>)
-    where
-        I: Iterator<Item = Event> + 'a,
-    {
+    fn filter_duplicate_events(
+        &self,
+        events: Vec<Event>,
+        room_events: &RoomEvents,
+    ) -> (Vec<Event>, Vec<OwnedEventId>) {
         let mut duplicated_event_ids = Vec::new();
 
         let events = self
-            .scan_and_learn(events, room_events)
+            .scan_and_learn(events.into_iter(), room_events)
             .filter_map(|decorated_event| match decorated_event {
                 Decoration::Unique(event) => Some(event),
                 Decoration::Duplicated(event) => {

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

@@ -181,7 +181,7 @@ impl RoomPagination {
             .collect::<Vec<_>>();
 
         let (new_events, duplicated_event_ids, all_deduplicated) =
-            state.collect_valid_and_duplicated_events(sync_events.clone().into_iter()).await?;
+            state.collect_valid_and_duplicated_events(sync_events.clone()).await?;
 
         let (backpagination_outcome, sync_timeline_events_diffs) = state
             .with_events_mut(move |room_events| {

crates/matrix-sdk/src/event_cache/room/mod.rs

@@ -424,9 +424,8 @@ impl RoomEventCacheInner {
             return Ok(());
         }
 
-        let (events, duplicated_event_ids, all_duplicates) = state
-            .collect_valid_and_duplicated_events(sync_timeline_events.clone().into_iter())
-            .await?;
+        let (events, duplicated_event_ids, all_duplicates) =
+            state.collect_valid_and_duplicated_events(sync_timeline_events.clone()).await?;
 
         let sync_timeline_events_diffs = if all_duplicates {
             // No new events, thus no need to change the room events.
@@ -658,13 +657,10 @@ mod private {
         /// possibly misplace them. And we should not be missing
         /// events either: the already-known events would have their own
         /// previous-batch token (it might already be consumed).
-        pub async fn collect_valid_and_duplicated_events<'a, I>(
-            &'a mut self,
-            events: I,
-        ) -> Result<(Vec<Event>, Vec<OwnedEventId>, bool), EventCacheError>
-        where
-            I: Iterator<Item = Event> + 'a,
-        {
+        pub async fn collect_valid_and_duplicated_events(
+            &mut self,
+            events: Vec<Event>,
+        ) -> Result<(Vec<Event>, Vec<OwnedEventId>, bool), EventCacheError> {
             let (events, duplicated_event_ids) =
                 self.deduplicator.filter_duplicate_events(events, &self.events).await?;