Struct SpaceRoomList 

pub struct SpaceRoomList { /* private fields */ }

The SpaceRoomListrepresents a paginated list of direct rooms that belong to a particular space.

It can be used to paginate through the list (and have live updates on the pagination state) as well as subscribe to changes as rooms are joined or left.

The SpaceRoomList also automatically subscribes to client room changes and updates the list accordingly as rooms are joined or left.

Examples

use futures_util::StreamExt;
use matrix_sdk::Client;
use matrix_sdk_ui::spaces::{
    SpaceService, room_list::SpaceRoomListPaginationState,
};
use ruma::owned_room_id;

let space_service = SpaceService::new(client.clone()).await;

// Get a list of all the rooms in a particular space
let room_list = space_service
    .space_room_list(owned_room_id!("!some_space:example.org"))
    .await;

// Start off with an empty and idle list
room_list.rooms().is_empty();

assert_eq!(
    room_list.pagination_state(),
    SpaceRoomListPaginationState::Idle { end_reached: false }
);

// Subscribe to pagination state updates
let pagination_state_stream =
    room_list.subscribe_to_pagination_state_updates();

// And to room list updates
let (_, room_stream) = room_list.subscribe_to_room_updates();

// Run this in a background task so it doesn't block
while let Some(pagination_state) = pagination_state_stream.next().await {
    println!("Received pagination state update: {pagination_state:?}");
}

// Run this in a background task so it doesn't block
while let Some(diffs) = room_stream.next().await {
    println!("Received room list update: {diffs:?}");
}

// Ask the room to load the next page
room_list.paginate().await.unwrap();

// And, if successful, rooms are available
let rooms = room_list.rooms();

Implementations

impl SpaceRoomList

pub async fn new(client: Client, space_id: OwnedRoomId) -> Self

Creates a new SpaceRoomList for the given space identifier.

pub fn space(&self) -> Option<SpaceRoom>

Returns the space of the room list if known.

pub fn subscribe_to_space_updates(&self) -> Subscriber<Option<SpaceRoom>>

Subscribe to space updates.

pub fn pagination_state(&self) -> SpaceRoomListPaginationState

Returns if the room list is currently paginating or not.

pub fn subscribe_to_pagination_state_updates( &self, ) -> Subscriber<SpaceRoomListPaginationState>

Subscribe to pagination updates.

pub fn rooms(&self) -> Vec<SpaceRoom>

Return the current list of rooms.

pub fn subscribe_to_room_updates( &self, ) -> (Vector<SpaceRoom>, VectorSubscriberBatchedStream<SpaceRoom>)

Subscribes to room list updates.

pub async fn paginate(&self) -> Result<(), Error>

Ask the list to retrieve the next page if the end hasn’t been reached yet. Otherwise it no-ops.

pub async fn reset(&self)

Clears the room list back to its initial state so that any new changes to the hierarchy will be included the next time Self::paginate is called.

This is useful when you’ve added or removed children from the space as the list is based on a cached state that lives server-side, meaning the /hierarchy request needs to be restarted from scratch to pick up the changes.