Struct BroadcastBus 

pub struct BroadcastBus<E> { /* private fields */ }

A typed publish/subscribe bus that broadcasts each event to all subscribers.

Every handle can both publish and receive, and it receives what it publishes itself. Use subscribe to add an independent consumer; an event published after a handle subscribes is delivered to it. A subscriber only sees events published after it subscribed, mirroring a live pub/sub channel.

Each handle holds a publisher of its own, so the bus stays open while any handle exists and next_event on a BroadcastBus never returns None: it waits until an event arrives. A wait given up, by a timeout or a select!, takes no event.

Examples

use pamoja_core::EventBus;
use pamoja_bus::BroadcastBus;

let bus = BroadcastBus::new(16);
let mut subscriber = bus.subscribe();
bus.publish("reading").await?;
assert_eq!(subscriber.next_event().await?, Some("reading"));

Implementations

impl<E: Clone> BroadcastBus<E>

pub fn new(capacity: usize) -> Self

Creates a bus buffering unread events for each subscriber.

Arguments

• capacity - the per-subscriber buffer depth, rounded up to the next power of two; a subscriber further behind than the buffer holds drops the events it missed. Values below one are raised to one, and values above MAX_CAPACITY are lowered to it.

Returns

A bus with one handle that can publish and receive.

pub fn subscribe(&self) -> Self

Creates another handle to the same bus with its own independent subscription.

Returns

A handle that receives events published after this call and can also publish.

pub fn publisher(&self) -> EventPublisher<E>

Creates a publish-only handle to the same bus.

Returns

A handle that publishes without borrowing this one, so it can announce from another task while this handle waits in next_event.

pub fn missed(&self) -> u64

Counts the events this handle lost by falling behind.

Returns

How many events were dropped from this handle’s buffer before it read them, since it subscribed.

Trait Implementations

impl<E: Clone> EventBus for BroadcastBus<E>

type Event = E

The event type carried by this bus.

async fn publish(&self, event: Self::Event) -> Result<()>

Publishes an event to every current subscriber.

async fn next_event(&mut self) -> Result<Option<Self::Event>>

Awaits the next event for this subscriber.