Struct RoomManager 

pub struct RoomManager { /* private fields */ }

Available on crate feature websockets and non-WebAssembly only.

Manages multiple WebSocket rooms

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();

let room = manager.create_room("lobby".to_string()).await;
assert_eq!(room.id(), "lobby");
assert_eq!(manager.room_count().await, 1);

Implementations

impl RoomManager

pub fn new() -> RoomManager

Create a new RoomManager

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();
assert_eq!(manager.room_count().await, 0);

pub async fn create_room(&self, id: String) -> Arc<Room>

Create a new room

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();
let room = manager.create_room("game_room".to_string()).await;
assert_eq!(room.id(), "game_room");

pub async fn get_room(&self, id: &str) -> Option<Arc<Room>>

Get an existing room

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();
manager.create_room("test".to_string()).await;

let room = manager.get_room("test").await;
assert!(room.is_some());
assert_eq!(room.unwrap().id(), "test");

pub async fn get_or_create_room(&self, id: String) -> Arc<Room>

Get or create a room

This method uses a single write lock to avoid TOCTOU race conditions that could occur with separate get and create operations.

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();

let room1 = manager.get_or_create_room("auto".to_string()).await;
let room2 = manager.get_or_create_room("auto".to_string()).await;

assert_eq!(room1.id(), room2.id());

pub async fn delete_room(&self, id: &str) -> Result<(), RoomError>

Delete a room

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();
manager.create_room("temporary".to_string()).await;

assert!(manager.get_room("temporary").await.is_some());

manager.delete_room("temporary").await.unwrap();
assert!(manager.get_room("temporary").await.is_none());

pub async fn room_count(&self) -> usize

Get the number of rooms

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();
assert_eq!(manager.room_count().await, 0);

manager.create_room("room1".to_string()).await;
manager.create_room("room2".to_string()).await;

assert_eq!(manager.room_count().await, 2);

pub async fn room_ids(&self) -> Vec<String>

Get all room IDs

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();

manager.create_room("alpha".to_string()).await;
manager.create_room("beta".to_string()).await;

let ids = manager.room_ids().await;
assert_eq!(ids.len(), 2);
assert!(ids.contains(&"alpha".to_string()));
assert!(ids.contains(&"beta".to_string()));

pub async fn has_room(&self, id: &str) -> bool

Check if a room exists

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();
manager.create_room("exists".to_string()).await;

assert!(manager.has_room("exists").await);
assert!(!manager.has_room("missing").await);

pub async fn cleanup_empty_rooms(&self)

Delete all empty rooms

Examples

use reinhardt_websockets::room::RoomManager;
use reinhardt_websockets::WebSocketConnection;
use tokio::sync::mpsc;
use std::sync::Arc;

let manager = RoomManager::new();

let empty_room = manager.create_room("empty".to_string()).await;
let occupied_room = manager.create_room("occupied".to_string()).await;

let (tx, _rx) = mpsc::unbounded_channel();
let client = Arc::new(WebSocketConnection::new("user".to_string(), tx));
occupied_room.join("user".to_string(), client).await.unwrap();

manager.cleanup_empty_rooms().await;

assert!(!manager.has_room("empty").await);
assert!(manager.has_room("occupied").await);

pub async fn join_room( &self, room_id: String, connection: Arc<WebSocketConnection>, ) -> Result<(), RoomError>

Add a client to a specific room

Examples

use reinhardt_websockets::room::RoomManager;
use reinhardt_websockets::WebSocketConnection;
use tokio::sync::mpsc;
use std::sync::Arc;

let manager = RoomManager::new();
manager.create_room("game".to_string()).await;

let (tx, _rx) = mpsc::unbounded_channel();
let conn = Arc::new(WebSocketConnection::new("player1".to_string(), tx));

manager.join_room("game".to_string(), conn).await.unwrap();

pub async fn leave_room( &self, room_id: &str, user_id: &str, ) -> Result<(), RoomError>

Remove a client from a specific room

Examples

use reinhardt_websockets::room::RoomManager;
use reinhardt_websockets::WebSocketConnection;
use tokio::sync::mpsc;
use std::sync::Arc;

let manager = RoomManager::new();
manager.create_room("chat".to_string()).await;

let (tx, _rx) = mpsc::unbounded_channel();
let conn = Arc::new(WebSocketConnection::new("user1".to_string(), tx));

manager.join_room("chat".to_string(), conn).await.unwrap();
manager.leave_room("chat", "user1").await.unwrap();

pub async fn get_room_size(&self, room_id: &str) -> usize

Get the number of clients in a specific room

Examples

use reinhardt_websockets::room::RoomManager;
use reinhardt_websockets::WebSocketConnection;
use tokio::sync::mpsc;
use std::sync::Arc;

let manager = RoomManager::new();
manager.create_room("lobby".to_string()).await;

let (tx, _rx) = mpsc::unbounded_channel();
let conn = Arc::new(WebSocketConnection::new("user1".to_string(), tx));

manager.join_room("lobby".to_string(), conn).await.unwrap();
assert_eq!(manager.get_room_size("lobby").await, 1);

pub async fn broadcast_to_room( &self, room_id: &str, message: Message, ) -> Result<BroadcastResult, RoomError>

Broadcast a message to all clients in a specific room.

Returns a BroadcastResult describing which clients received the message and which failed. Returns RoomError::RoomNotFound if the room does not exist.

Examples

use reinhardt_websockets::room::RoomManager;
use reinhardt_websockets::{WebSocketConnection, Message};
use tokio::sync::mpsc;
use std::sync::Arc;

let manager = RoomManager::new();
manager.create_room("announcement".to_string()).await;

let (tx, mut rx) = mpsc::unbounded_channel();
let conn = Arc::new(WebSocketConnection::new("listener".to_string(), tx));

manager.join_room("announcement".to_string(), conn).await.unwrap();

let msg = Message::text("Hello everyone!".to_string());
let result = manager.broadcast_to_room("announcement", msg).await.unwrap();
assert!(result.is_complete_success());

pub async fn broadcast_to_room_with_timeout( &self, room_id: &str, message: Message, send_timeout: Duration, ) -> Result<BroadcastResult, RoomError>

Broadcasts a message to all clients in a room with a per-client timeout.

Slow consumers that do not accept the message within the given timeout are treated as failed and removed from the room.

Returns RoomError::RoomNotFound if the room does not exist.

Examples

use reinhardt_websockets::room::RoomManager;
use reinhardt_websockets::{WebSocketConnection, Message};
use tokio::sync::mpsc;
use std::sync::Arc;
use std::time::Duration;

let manager = RoomManager::new();
manager.create_room("timeout_test".to_string()).await;

let (tx, _rx) = mpsc::unbounded_channel();
let conn = Arc::new(WebSocketConnection::new("user1".to_string(), tx));

manager.join_room("timeout_test".to_string(), conn).await.unwrap();

let msg = Message::text("Hello!".to_string());
let result = manager
    .broadcast_to_room_with_timeout("timeout_test", msg, Duration::from_secs(5))
    .await
    .unwrap();
assert!(result.is_complete_success());

pub async fn broadcast_to_all(&self, message: Message) -> BroadcastResult

Broadcast a message to all clients in all rooms.

Returns a BroadcastResult aggregated across all rooms, reporting which clients received the message and which failed.

Examples

use reinhardt_websockets::room::RoomManager;
use reinhardt_websockets::{WebSocketConnection, Message};
use tokio::sync::mpsc;
use std::sync::Arc;

let manager = RoomManager::new();
manager.create_room("room1".to_string()).await;
manager.create_room("room2".to_string()).await;

let (tx1, _rx1) = mpsc::unbounded_channel();
let (tx2, _rx2) = mpsc::unbounded_channel();

let conn1 = Arc::new(WebSocketConnection::new("user1".to_string(), tx1));
let conn2 = Arc::new(WebSocketConnection::new("user2".to_string(), tx2));

manager.join_room("room1".to_string(), conn1).await.unwrap();
manager.join_room("room2".to_string(), conn2).await.unwrap();

let msg = Message::text("System message".to_string());
let result = manager.broadcast_to_all(msg).await;
assert!(result.is_complete_success());

pub async fn get_all_rooms(&self) -> Vec<String>

Get all room IDs (alias for room_ids for compatibility)

Examples

use reinhardt_websockets::room::RoomManager;

let manager = RoomManager::new();
manager.create_room("alpha".to_string()).await;
manager.create_room("beta".to_string()).await;

let rooms = manager.get_all_rooms().await;
assert_eq!(rooms.len(), 2);
assert!(rooms.contains(&"alpha".to_string()));
assert!(rooms.contains(&"beta".to_string()));

Trait Implementations

impl Default for RoomManager

fn default() -> RoomManager

Returns the “default value” for a type.