Struct EventRegistry 

pub struct EventRegistry { /* private fields */ }

👎Deprecated since 0.1.0:

Use Bevy ECS events (scarab-client/src/events/bevy_events.rs) instead of Arc<Mutex<EventRegistry>>. See crates/scarab-plugin-api/src/events/registry.rs module docs for migration guide.

Central registry for event handlers

DEPRECATED: Use Bevy ECS events instead. See module documentation for migration guide.

This registry uses Arc<Mutex<>> for thread synchronization, which is incompatible with Bevy’s lock-free ECS architecture. The daemon still uses this for plugin-side event handling, but client-side code should use typed Bevy events.

Migration Path

• Daemon plugins: Continue using DaemonEventDispatcher which wraps this registry
• Client code: Use typed events from scarab-client/src/events/bevy_events.rs
• New code: Always prefer Bevy events over this registry

Thread Safety

The registry is NOT thread-safe by default. Wrap it in a Mutex or RwLock for concurrent access from multiple threads.

Implementations

impl EventRegistry

pub fn new() -> Self

Create a new empty event registry

pub fn register( &mut self, event_type: EventType, priority: i32, plugin_name: &str, handler: EventHandler, ) -> u64

Register a new event handler

Arguments

• event_type - Type of event to listen for
• priority - Handler priority (higher values = called first)
• plugin_name - Name of the plugin registering this handler
• handler - The handler function

Returns

A unique handler ID that can be used to unregister the handler later.

Example

let id = registry.register(
    EventType::Bell,
    100,
    "my-plugin",
    Box::new(|args| {
        println!("Bell rang!");
        EventResult::Continue
    })
);

pub fn unregister(&mut self, handler_id: u64) -> bool

Unregister a handler by ID

Returns

true if a handler was removed, false if no handler with that ID was found.

pub fn unregister_plugin(&mut self, plugin_name: &str) -> usize

Unregister all handlers for a specific plugin

Returns

The number of handlers removed.

pub fn dispatch(&self, args: &EventArgs) -> Vec<EventResult>

Dispatch an event to all registered handlers

Handlers are called in priority order (highest first). If any handler returns EventResult::Stop, subsequent handlers are not called.

Returns

A vector of all results returned by handlers (may be empty if no handlers are registered or if an early handler stopped processing).

pub fn get_handlers(&self, event_type: &EventType) -> &[HandlerEntry]

Get all handlers for a specific event type

Returns an empty slice if no handlers are registered for that event.

pub fn handler_count(&self, event_type: &EventType) -> usize

Get the number of registered handlers for an event type

pub fn total_handler_count(&self) -> usize

Get the total number of registered handlers across all events

pub fn clear_event(&mut self, event_type: &EventType)

Clear all handlers for a specific event type

pub fn clear_all(&mut self)

Clear all handlers from the registry

pub fn registered_events(&self) -> Vec<EventType>

Get a list of all event types that have registered handlers

Trait Implementations

impl Default for EventRegistry

fn default() -> Self

Returns the “default value” for a type.