178 lines
5.9 KiB
Rust
178 lines
5.9 KiB
Rust
//! Builder for [`SlidingSyncList`].
|
|
|
|
use std::{
|
|
fmt::Debug,
|
|
sync::{atomic::AtomicBool, Arc, RwLock as StdRwLock},
|
|
};
|
|
|
|
use eyeball::unique::Observable;
|
|
use eyeball_im::ObservableVector;
|
|
use im::Vector;
|
|
use ruma::{api::client::sync::sync_events::v4, events::StateEventType, UInt};
|
|
|
|
use super::{Error, RoomListEntry, SlidingSyncList, SlidingSyncMode, SlidingSyncState};
|
|
use crate::Result;
|
|
|
|
/// The default name for the full sync list.
|
|
pub const FULL_SYNC_LIST_NAME: &str = "full-sync";
|
|
|
|
/// Builder for [`SlidingSyncList`].
|
|
#[derive(Clone, Debug)]
|
|
pub struct SlidingSyncListBuilder {
|
|
sync_mode: SlidingSyncMode,
|
|
sort: Vec<String>,
|
|
required_state: Vec<(StateEventType, String)>,
|
|
full_sync_batch_size: u32,
|
|
full_sync_maximum_number_of_rooms_to_fetch: Option<u32>,
|
|
send_updates_for_items: bool,
|
|
filters: Option<v4::SyncRequestListFilters>,
|
|
timeline_limit: Option<UInt>,
|
|
name: Option<String>,
|
|
state: SlidingSyncState,
|
|
rooms_list: Vector<RoomListEntry>,
|
|
ranges: Vec<(UInt, UInt)>,
|
|
}
|
|
|
|
impl SlidingSyncListBuilder {
|
|
pub(super) fn new() -> Self {
|
|
Self {
|
|
sync_mode: SlidingSyncMode::default(),
|
|
sort: vec!["by_recency".to_owned(), "by_name".to_owned()],
|
|
required_state: vec![
|
|
(StateEventType::RoomEncryption, "".to_owned()),
|
|
(StateEventType::RoomTombstone, "".to_owned()),
|
|
],
|
|
full_sync_batch_size: 20,
|
|
full_sync_maximum_number_of_rooms_to_fetch: None,
|
|
send_updates_for_items: false,
|
|
filters: None,
|
|
timeline_limit: None,
|
|
name: None,
|
|
state: SlidingSyncState::default(),
|
|
rooms_list: Vector::new(),
|
|
ranges: Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// Create a Builder set up for full sync.
|
|
pub fn default_with_fullsync() -> Self {
|
|
Self::new().name(FULL_SYNC_LIST_NAME).sync_mode(SlidingSyncMode::PagingFullSync)
|
|
}
|
|
|
|
/// Which SlidingSyncMode to start this list under.
|
|
pub fn sync_mode(mut self, value: SlidingSyncMode) -> Self {
|
|
self.sync_mode = value;
|
|
self
|
|
}
|
|
|
|
/// Sort the rooms list by this.
|
|
pub fn sort(mut self, value: Vec<String>) -> Self {
|
|
self.sort = value;
|
|
self
|
|
}
|
|
|
|
/// Required states to return per room.
|
|
pub fn required_state(mut self, value: Vec<(StateEventType, String)>) -> Self {
|
|
self.required_state = value;
|
|
self
|
|
}
|
|
|
|
/// When doing a full-sync, this method defines the value by which ranges of
|
|
/// rooms will be extended.
|
|
pub fn full_sync_batch_size(mut self, value: u32) -> Self {
|
|
self.full_sync_batch_size = value;
|
|
self
|
|
}
|
|
|
|
/// When doing a full-sync, this method defines the total limit of rooms to
|
|
/// load (it can be useful for gigantic accounts).
|
|
pub fn full_sync_maximum_number_of_rooms_to_fetch(
|
|
mut self,
|
|
value: impl Into<Option<u32>>,
|
|
) -> Self {
|
|
self.full_sync_maximum_number_of_rooms_to_fetch = value.into();
|
|
self
|
|
}
|
|
|
|
/// Whether the list should send `UpdatedAt`-Diff signals for rooms that
|
|
/// have changed.
|
|
pub fn send_updates_for_items(mut self, value: bool) -> Self {
|
|
self.send_updates_for_items = value;
|
|
self
|
|
}
|
|
|
|
/// Any filters to apply to the query.
|
|
pub fn filters(mut self, value: Option<v4::SyncRequestListFilters>) -> Self {
|
|
self.filters = value;
|
|
self
|
|
}
|
|
|
|
/// 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());
|
|
self
|
|
}
|
|
|
|
/// Reset the limit of regular events to fetch for the timeline. It is left
|
|
/// to the server to decide how many to send back
|
|
pub fn no_timeline_limit(mut self) -> Self {
|
|
self.timeline_limit = Default::default();
|
|
self
|
|
}
|
|
|
|
/// Set the name of this list, to easily recognize it.
|
|
pub fn name(mut self, value: impl Into<String>) -> Self {
|
|
self.name = Some(value.into());
|
|
self
|
|
}
|
|
|
|
/// 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();
|
|
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())];
|
|
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()));
|
|
self
|
|
}
|
|
|
|
/// Set the ranges to fetch.
|
|
pub fn reset_ranges(mut self) -> Self {
|
|
self.ranges.clear();
|
|
self
|
|
}
|
|
|
|
/// Build the list.
|
|
pub fn build(self) -> Result<SlidingSyncList> {
|
|
let mut rooms_list = ObservableVector::new();
|
|
rooms_list.append(self.rooms_list);
|
|
|
|
Ok(SlidingSyncList {
|
|
sync_mode: self.sync_mode,
|
|
sort: self.sort,
|
|
required_state: self.required_state,
|
|
full_sync_batch_size: self.full_sync_batch_size,
|
|
send_updates_for_items: self.send_updates_for_items,
|
|
full_sync_maximum_number_of_rooms_to_fetch: self
|
|
.full_sync_maximum_number_of_rooms_to_fetch,
|
|
filters: self.filters,
|
|
timeline_limit: Arc::new(StdRwLock::new(Observable::new(self.timeline_limit))),
|
|
name: self.name.ok_or(Error::BuildMissingField("name"))?,
|
|
state: Arc::new(StdRwLock::new(Observable::new(self.state))),
|
|
maximum_number_of_rooms: Arc::new(StdRwLock::new(Observable::new(None))),
|
|
rooms_list: Arc::new(StdRwLock::new(rooms_list)),
|
|
ranges: Arc::new(StdRwLock::new(Observable::new(self.ranges))),
|
|
is_cold: Arc::new(AtomicBool::new(false)),
|
|
rooms_updated_broadcast: Arc::new(StdRwLock::new(Observable::new(()))),
|
|
})
|
|
}
|
|
}
|