Struct WebSocketState 

pub struct WebSocketState<H: WebSocketHandler> { /* private fields */ }

WebSocket state shared across connections

Contains the message handler and optional JSON schemas for validating incoming and outgoing messages. This state is shared among all connections to the same WebSocket endpoint.

Implementations

impl<H: WebSocketHandler + 'static> WebSocketState<H>

pub fn new(handler: H) -> Self

Create new WebSocket state with a handler

Creates a new state without message or response validation schemas. Messages and responses are not validated.

Arguments

• handler - The message handler implementation

Example

let state = WebSocketState::new(MyHandler);

pub fn with_schemas( handler: H, message_schema: Option<Value>, response_schema: Option<Value>, ) -> Result<Self, String>

Create new WebSocket state with a handler and optional validation schemas

Creates a new state with optional JSON schemas for validating incoming messages and outgoing responses. If a schema is provided and validation fails, the message or response is rejected.

Arguments

• handler - The message handler implementation
• message_schema - Optional JSON schema for validating client messages
• response_schema - Optional JSON schema for validating handler responses

Returns

• Ok(state) - Successfully created state
• Err(msg) - Invalid schema provided

Example

use serde_json::json;

let message_schema = json!({
    "type": "object",
    "properties": {
        "type": {"type": "string"},
        "data": {"type": "string"}
    }
});

let state = WebSocketState::with_schemas(
    MyHandler,
    Some(message_schema),
    None,
)?;

pub fn with_factory<F>( factory: F, message_schema: Option<Value>, response_schema: Option<Value>, ) -> Result<Self, String>

where F: Fn() -> Result<H, String> + Send + Sync + 'static,

Create new WebSocket state with a handler factory and optional validation schemas.

The factory is invoked once per connection, enabling per-connection handler state.

pub async fn on_connect(&self)

Invoke the connection hook for testing.

pub async fn on_disconnect(&self)

Invoke the disconnect hook for testing.

pub async fn handle_message_validated( &self, message: Value, ) -> Result<Option<Value>, String>

Validate and handle an incoming message without a socket transport.

Trait Implementations

impl<H: WebSocketHandler> Clone for WebSocketState<H>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<H: WebSocketHandler> Debug for WebSocketState<H>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.