sliding sync: Use RangeInclusive<u32> instead of raw start/end UInt values (#1877)

* chore: use RangeInclusive instead of raw start/end integers for ranges in sliding sync
* chore: have timeline_limit use a u32 instead of a Ruma UInt
* chore: Remove all the `Into<u32>` generics on timeline_limit and ranges APIs
* chore: introduce a `Bound` type alias for u32

Signed-off-by: Benjamin Bouvier <public@benj.me>

Author: bnjbvr

bindings/matrix-sdk-ffi/src/sliding_sync.rs

@@ -8,7 +8,7 @@ use matrix_sdk::ruma::{
         v4::RoomSubscription as RumaRoomSubscription,
         UnreadNotificationsCount as RumaUnreadNotificationsCount,
     },
-    assign, IdParseError, OwnedRoomId, RoomId, UInt,
+    assign, IdParseError, OwnedRoomId, RoomId,
 };
 pub use matrix_sdk::{
     room::timeline::Timeline, ruma::api::client::sync::sync_events::v4::SyncRequestListFilters,
@@ -533,9 +533,9 @@ impl SlidingSyncListBuilder {
         Arc::new(builder)
     }
 
-    pub fn add_range(self: Arc<Self>, from: u32, to: u32) -> Arc<Self> {
+    pub fn add_range(self: Arc<Self>, from: u32, to_included: u32) -> Arc<Self> {
         let mut builder = unwrap_or_clone_arc(self);
-        builder.inner = builder.inner.add_range(from, to);
+        builder.inner = builder.inner.add_range(from..=to_included);
         Arc::new(builder)
     }
 
@@ -631,15 +631,15 @@ impl SlidingSyncList {
     /// Remember to cancel the existing stream and fetch a new one as this will
     /// only be applied on the next request.
     pub fn set_range(&self, start: u32, end: u32) -> Result<(), SlidingSyncError> {
-        self.inner.set_range(start, end).map_err(Into::into)
+        self.inner.set_range(start..=end).map_err(Into::into)
     }
 
     /// Set the ranges to fetch
     ///
     /// Remember to cancel the existing stream and fetch a new one as this will
     /// only be applied on the next request.
     pub fn add_range(&self, start: u32, end: u32) -> Result<(), SlidingSyncError> {
-        self.inner.add_range((start, end)).map_err(Into::into)
+        self.inner.add_range(start..=end).map_err(Into::into)
     }
 
     /// Reset the ranges
@@ -654,7 +654,7 @@ impl SlidingSyncList {
 
     /// The current timeline limit
     pub fn get_timeline_limit(&self) -> Option<u32> {
-        self.inner.timeline_limit().map(|limit| u32::try_from(limit).unwrap_or_default())
+        self.inner.timeline_limit()
     }
 
     /// The current timeline limit
@@ -664,7 +664,7 @@ impl SlidingSyncList {
 
     /// Unset the current timeline limit
     pub fn unset_timeline_limit(&self) {
-        self.inner.set_timeline_limit::<UInt>(None)
+        self.inner.set_timeline_limit(None)
     }
 }
 

crates/matrix-sdk/src/sliding_sync/README.md

@@ -79,7 +79,7 @@ let list_builder = SlidingSyncList::builder("main_list")
         v4::SyncRequestListFilters::default(), { is_dm: Some(true)}
     )))
     .sort(vec!["by_recency".to_owned()])
-    .set_range(0u32, 9u32);
+    .set_range(0u32..=9);
 ```
 
 Please refer to the [specification][MSC], the [Ruma types][ruma-types],
@@ -438,7 +438,7 @@ let full_sync_list = SlidingSyncList::builder(&full_sync_list_name)
 
 let active_list = SlidingSyncList::builder(&active_list_name) // the active window
     .sync_mode(SlidingSyncMode::Selective)  // sync up the specific range only
-    .set_range(0u32, 9u32) // only the top 10 items
+    .set_range(0u32..=9) // only the top 10 items
     .sort(vec!["by_recency".to_owned()]) // last active
     .timeline_limit(5u32) // add the last 5 timeline items for room preview and faster timeline loading
     .required_state(vec![ // we want to know immediately:

crates/matrix-sdk/src/sliding_sync/list/builder.rs

@@ -3,16 +3,17 @@
 use std::{
     convert::identity,
     fmt,
+    ops::RangeInclusive,
     sync::{Arc, RwLock as StdRwLock},
 };
 
 use eyeball::unique::Observable;
 use eyeball_im::ObservableVector;
-use ruma::{api::client::sync::sync_events::v4, events::StateEventType, UInt};
+use ruma::{api::client::sync::sync_events::v4, events::StateEventType};
 use tokio::sync::mpsc::Sender;
 
 use super::{
-    super::SlidingSyncInternalMessage, SlidingSyncList, SlidingSyncListInner,
+    super::SlidingSyncInternalMessage, Bound, SlidingSyncList, SlidingSyncListInner,
     SlidingSyncListRequestGenerator, SlidingSyncMode, SlidingSyncState,
 };
 
@@ -28,9 +29,9 @@ pub struct SlidingSyncListBuilder {
     full_sync_batch_size: u32,
     full_sync_maximum_number_of_rooms_to_fetch: Option<u32>,
     filters: Option<v4::SyncRequestListFilters>,
-    timeline_limit: Option<UInt>,
+    timeline_limit: Option<Bound>,
     name: String,
-    ranges: Vec<(UInt, UInt)>,
+    ranges: Vec<RangeInclusive<Bound>>,
     once_built: Arc<Box<dyn Fn(SlidingSyncList) -> SlidingSyncList + Send + Sync>>,
 }
 
@@ -130,8 +131,8 @@ impl SlidingSyncListBuilder {
     }
 
     /// Set the limit of regular events to fetch for the timeline.
-    pub fn timeline_limit<U: Into<UInt>>(mut self, timeline_limit: U) -> Self {
-        self.timeline_limit = Some(timeline_limit.into());
+    pub fn timeline_limit(mut self, timeline_limit: Bound) -> Self {
+        self.timeline_limit = Some(timeline_limit);
         self
     }
 
@@ -143,24 +144,24 @@ impl SlidingSyncListBuilder {
     }
 
     /// Set the ranges to fetch.
-    pub fn ranges<U: Into<UInt>>(mut self, range: Vec<(U, U)>) -> Self {
-        self.ranges = range.into_iter().map(|(a, b)| (a.into(), b.into())).collect();
+    pub fn ranges(mut self, ranges: Vec<RangeInclusive<Bound>>) -> Self {
+        self.ranges = ranges;
         self
     }
 
-    /// Set a single range fetch.
-    pub fn set_range<U: Into<UInt>>(mut self, from: U, to: U) -> Self {
-        self.ranges = vec![(from.into(), to.into())];
+    /// Set a single range to fetch.
+    pub fn set_range(mut self, range: RangeInclusive<Bound>) -> Self {
+        self.ranges = vec![range];
         self
     }
 
     /// Set the ranges to fetch.
-    pub fn add_range<U: Into<UInt>>(mut self, from: U, to: U) -> Self {
-        self.ranges.push((from.into(), to.into()));
+    pub fn add_range(mut self, range: RangeInclusive<Bound>) -> Self {
+        self.ranges.push(range);
         self
     }
 
-    /// Set the ranges to fetch.
+    /// Reset the ranges to fetch.
     pub fn reset_ranges(mut self) -> Self {
         self.ranges.clear();
         self