Struct SparqlWebSocketHandler 

pub struct SparqlWebSocketHandler<'a> {
    pub quins: &'a [NQuin],
    pub sessions: [Option<WebSocketSession>; 32],
    pub session_count: u8,
    pub subscriptions: HashMap<String, Subscription>,
    pub initialized: bool,
}

SPARQL WebSocket handler

Fields

quins: &'a [NQuin]

sessions: [Option<WebSocketSession>; 32]

session_count: u8

subscriptions: HashMap<String, Subscription>

Active subscriptions keyed by subscription id.

initialized: bool

Whether initialize has been called.

Implementations

impl<'a> SparqlWebSocketHandler<'a>

pub fn new(quins: &'a [NQuin]) -> Self

pub fn initialize(&mut self) -> Result<(), String>

Initialize the handler for use. Resets subscription state and marks the handler ready. Must be called before subscribing/notifying so downstream code can rely on a deterministic start state.

pub fn register_session(&mut self) -> Result<u64, String>

Register a new WebSocket session

pub fn unregister_session(&mut self, session_id: u64) -> Result<(), String>

Unregister a WebSocket session

pub fn handle_query_formatted( &self, query: &str, format: &str, _session_id: u64, ) -> Result<String, String>

Handle a WebSocket query, returning formatted output (json or xml).

This is the format-aware, session-scoped variant. The simpler handle_query returns serialized JSON bytes.

pub fn stream_query_results( &self, query: &str, chunk_size: usize, _session_id: u64, ) -> Result<Vec<String>, String>

Stream query results in chunks, executing the query and formatting each chunk as JSON. This is the query-executing variant. The simpler stream_results splits an already-serialized byte buffer.

pub fn subscribe_session( &mut self, session_id: u64, query: &str, ) -> Result<u64, String>

Subscribe a session to real-time updates for a query (session-based).

This is the numeric-session variant. The string-keyed subscribe is the subscription notification API.

pub fn unsubscribe_session(&mut self, session_id: u64) -> Result<(), String>

Unsubscribe a session from updates (session-based).

pub fn notify_session_subscribers(&self, query_hash: u64) -> Vec<u64>

Notify session subscribers of updates (session-based), returning the session ids whose active query matches query_hash.

pub fn subscribe( &mut self, client_id: &str, query: &str, ) -> Result<String, String>

Register a subscription for a client and return the subscription id.

The subscription id is derived from the query (via generate_60bit_token) so the same query re-subscribed by the same client yields a stable id. The query and client_id are stored in the subscriptions map for later notification.

pub fn unsubscribe(&mut self, subscription_id: &str) -> Result<(), String>

Remove a subscription by its id. Returns an error if the subscription does not exist.

pub fn get_subscriptions(&self) -> Vec<&Subscription>

List all active subscriptions.

pub fn subscription_count(&self) -> usize

Count active subscriptions.

pub fn notify_subscribers(&self, event_data: &str) -> Vec<(String, String)>

Notify all active subscribers of an event.

For each subscription, returns a (client_id, notification_message) pair. The notification message is a JSON-like string containing the subscription’s query and the event data, so a transport layer can push it directly to the connected client.

pub fn handle_query(&self, query: &str) -> Result<Vec<u8>, String>

Execute a SPARQL query and return the results as serialized bytes in a simple JSON format. This is the WebSocket query handler entry point.

pub fn stream_results(&self, results: &[u8], chunk_size: usize) -> Vec<Vec<u8>>

Split a serialized result buffer into chunks for streaming over WebSocket frames. Each chunk is at most chunk_size bytes (the final chunk may be smaller).

Trait Implementations

impl<'a> Default for SparqlWebSocketHandler<'a>

fn default() -> Self

Returns the “default value” for a type.