Struct InProcessEventBus 

pub struct InProcessEventBus { /* private fields */ }

In-process, synchronous event bus implementation.

This is the default event bus implementation that delivers events synchronously to all registered handlers in the same process.

Thread Safety

Uses Arc<Mutex<>> internally for thread-safe handler management.

Performance

• Synchronous delivery means handlers block the publisher
• Handlers are called sequentially in subscription order
• For high-throughput scenarios, consider async/queue-based implementations

Example

use arc_core::event_bus::{EventBus, EventHandler, InProcessEventBus};
use arc_core::event::Event;
use serde_json::json;
use async_trait::async_trait;

struct LogHandler;

#[async_trait]
impl EventHandler for LogHandler {
    fn handles(&self) -> Vec<String> {
        vec!["UserCreated".to_string()]
    }

    async fn handle(&self, event: &Event) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        println!("Event logged: {}", event.event_type);
        Ok(())
    }
}

let mut bus = InProcessEventBus::new();
bus.subscribe(Box::new(LogHandler)).await?;

let event = Event::new("User", "user-1", 1, "UserCreated", json!({}));
bus.publish(vec![event]).await?;

Implementations

impl InProcessEventBus

pub fn new() -> Self

Create a new in-process event bus.

Example

use arc_core::event_bus::InProcessEventBus;

let bus = InProcessEventBus::new();

pub async fn handler_count(&self) -> usize

Get the number of registered handlers.

Useful for testing and diagnostics.

Example

use arc_core::event_bus::InProcessEventBus;

let bus = InProcessEventBus::new();
assert_eq!(bus.handler_count().await, 0);

Trait Implementations

impl Clone for InProcessEventBus

fn clone(&self) -> InProcessEventBus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for InProcessEventBus

fn default() -> Self

Returns the “default value” for a type.

impl EventBus for InProcessEventBus

fn publish<'life0, 'async_trait>( &'life0 self, events: Vec<Event>, ) -> Pin<Box<dyn Future<Output = EventBusResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Publish events to all subscribed handlers.

fn subscribe<'life0, 'async_trait>( &'life0 mut self, handler: Box<dyn EventHandler>, ) -> Pin<Box<dyn Future<Output = EventBusResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Subscribe an event handler to the bus.