Struct Room 

pub struct Room { /* private fields */ }

Available on crate feature websockets and native only.

A WebSocket room that manages multiple client connections

Examples

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

let room = Room::new("chat_room".to_string());

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

room.join("user1".to_string(), client).await.unwrap();
assert_eq!(room.client_count().await, 1);

Implementations

impl Room

pub fn new(id: String) -> Room

Create a new room with the given ID

Examples

use reinhardt_websockets::room::Room;

let room = Room::new("general".to_string());
assert_eq!(room.id(), "general");

pub fn id(&self) -> &str

Get the room ID

Examples

use reinhardt_websockets::room::Room;

let room = Room::new("lobby".to_string());
assert_eq!(room.id(), "lobby");

pub async fn join( &self, client_id: String, client: Arc<WebSocketConnection>, ) -> Result<(), RoomError>

Add a client to the room

Examples

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

let room = Room::new("chat".to_string());
let (tx, _rx) = mpsc::unbounded_channel();
let client = Arc::new(WebSocketConnection::new("alice".to_string(), tx));

room.join("alice".to_string(), client).await.unwrap();
assert!(room.has_client("alice").await);

pub async fn leave(&self, client_id: &str) -> Result<(), RoomError>

Remove a client from the room

Examples

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

let room = Room::new("chat".to_string());
let (tx, _rx) = mpsc::unbounded_channel();
let client = Arc::new(WebSocketConnection::new("bob".to_string(), tx));

room.join("bob".to_string(), client).await.unwrap();
assert!(room.has_client("bob").await);

room.leave("bob").await.unwrap();
assert!(!room.has_client("bob").await);

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

Broadcast a message to all clients in the room.

Returns a BroadcastResult that reports which clients received the message and which failed. Dead connections that fail during broadcast are automatically removed from the room.

Examples

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

let room = Room::new("chat".to_string());

let (tx1, _rx1) = mpsc::unbounded_channel();
let (tx2, _rx2) = mpsc::unbounded_channel();
let client1 = Arc::new(WebSocketConnection::new("user1".to_string(), tx1));
let client2 = Arc::new(WebSocketConnection::new("user2".to_string(), tx2));

room.join("user1".to_string(), client1).await.unwrap();
room.join("user2".to_string(), client2).await.unwrap();

let msg = Message::text("Hello everyone!".to_string());
let result = room.broadcast(msg).await;

assert!(result.is_complete_success());
assert_eq!(result.successful.len(), 2);

pub async fn broadcast_with_timeout( &self, message: Message, send_timeout: Duration, ) -> BroadcastResult

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

Slow consumers that do not accept the message within the given timeout are treated as failed and automatically removed from the room, applying backpressure to prevent slow receivers from blocking the entire broadcast.

Arguments

• message - The message to broadcast
• send_timeout - Maximum time to wait for each client to accept the message

Examples

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

let room = Room::new("chat".to_string());

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

room.join("user1".to_string(), client).await.unwrap();

let msg = Message::text("Hello!".to_string());
let result = room.broadcast_with_timeout(msg, Duration::from_secs(5)).await;

assert!(result.is_complete_success());

pub async fn send_to( &self, client_id: &str, message: Message, ) -> Result<(), RoomError>

Send a message to a specific client

Examples

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

let room = Room::new("private".to_string());

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

room.join("charlie".to_string(), client).await.unwrap();

let msg = Message::text("Private message".to_string());
room.send_to("charlie", msg).await.unwrap();

let received = rx.recv().await.unwrap();
match received {
    Message::Text { data } => assert_eq!(data, "Private message"),
    _ => panic!("Expected text message"),
}

pub async fn client_count(&self) -> usize

Get the number of clients in the room

Examples

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

let room = Room::new("game".to_string());
assert_eq!(room.client_count().await, 0);

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

let client1 = Arc::new(WebSocketConnection::new("player1".to_string(), tx1));
let client2 = Arc::new(WebSocketConnection::new("player2".to_string(), tx2));

room.join("player1".to_string(), client1).await.unwrap();
room.join("player2".to_string(), client2).await.unwrap();

assert_eq!(room.client_count().await, 2);

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

Get all client IDs in the room

Examples

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

let room = Room::new("meeting".to_string());

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

let client1 = Arc::new(WebSocketConnection::new("dave".to_string(), tx1));
let client2 = Arc::new(WebSocketConnection::new("eve".to_string(), tx2));

room.join("dave".to_string(), client1).await.unwrap();
room.join("eve".to_string(), client2).await.unwrap();

let ids = room.client_ids().await;
assert_eq!(ids.len(), 2);
assert!(ids.contains(&"dave".to_string()));
assert!(ids.contains(&"eve".to_string()));

pub async fn has_client(&self, client_id: &str) -> bool

Check if a client is in the room

Examples

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

let room = Room::new("support".to_string());

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

room.join("frank".to_string(), client).await.unwrap();

assert!(room.has_client("frank").await);
assert!(!room.has_client("grace").await);

pub async fn set_metadata<T>( &self, key: &str, value: T, ) -> Result<(), RoomError>

where T: Serialize,

Set metadata for the room

Examples

use reinhardt_websockets::room::Room;
use serde_json::json;

let room = Room::new("config".to_string());

room.set_metadata("max_users", json!(10)).await.unwrap();
room.set_metadata("topic", json!("General Discussion")).await.unwrap();

let max_users: i64 = room.get_metadata("max_users").await.unwrap().unwrap();
assert_eq!(max_users, 10);

pub async fn get_metadata<T>(&self, key: &str) -> Result<Option<T>, RoomError>

where T: DeserializeOwned,

Get metadata from the room

Examples

use reinhardt_websockets::room::Room;
use serde_json::json;

let room = Room::new("data".to_string());

room.set_metadata("counter", json!(42)).await.unwrap();

let counter: i64 = room.get_metadata("counter").await.unwrap().unwrap();
assert_eq!(counter, 42);

let missing: Option<String> = room.get_metadata("nonexistent").await.unwrap();
assert!(missing.is_none());

pub async fn remove_metadata(&self, key: &str) -> Option<Value>

Remove metadata from the room

Examples

use reinhardt_websockets::room::Room;
use serde_json::json;

let room = Room::new("temp".to_string());

room.set_metadata("temp_key", json!("temp_value")).await.unwrap();
assert!(room.get_metadata::<String>("temp_key").await.unwrap().is_some());

room.remove_metadata("temp_key").await;
assert!(room.get_metadata::<String>("temp_key").await.unwrap().is_none());

pub async fn clear_metadata(&self)

Clear all metadata

Examples

use reinhardt_websockets::room::Room;
use serde_json::json;

let room = Room::new("reset".to_string());

room.set_metadata("key1", json!("value1")).await.unwrap();
room.set_metadata("key2", json!("value2")).await.unwrap();

room.clear_metadata().await;

assert!(room.get_metadata::<String>("key1").await.unwrap().is_none());
assert!(room.get_metadata::<String>("key2").await.unwrap().is_none());

pub async fn is_empty(&self) -> bool

Check if room is empty

Examples

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

let room = Room::new("empty_check".to_string());
assert!(room.is_empty().await);

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

room.join("henry".to_string(), client).await.unwrap();
assert!(!room.is_empty().await);