Struct Broadcast 

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

Dynamic fan-out combinator. Takes ownership of an event, borrows it, and dispatches &E to N handlers, where N is determined at runtime.

One heap allocation per handler (boxing). Zero clones at dispatch — each handler receives &E.

Handlers must implement for<'e> Handler<&'e E>. Use Cloned or Owned to adapt owned-event handlers.

For static fan-out (known handler count, zero allocation), use FanOut.

Examples

use nexus_rt::{WorldBuilder, ResMut, IntoHandler, Handler, Broadcast, Resource};

#[derive(Resource)]
struct Counter(u64);

fn write_a(mut sink: ResMut<Counter>, event: &u32) {
    sink.0 += *event as u64;
}

let mut builder = WorldBuilder::new();
builder.register(Counter(0));
let mut world = builder.build();

let mut broadcast: Broadcast<u32> = Broadcast::new();
broadcast.add(write_a.into_handler(world.registry()));
broadcast.add(write_a.into_handler(world.registry()));
broadcast.run(&mut world, 5u32);
assert_eq!(world.resource::<Counter>().0, 10);

Implementations

impl<E> Broadcast<E>

pub fn new() -> Self

Create an empty broadcast with no handlers.

pub fn add<H: for<'e> Handler<&'e E> + Send + 'static>(&mut self, handler: H)

Add a handler to the broadcast.

pub fn len(&self) -> usize

Returns the number of handlers.

pub fn is_empty(&self) -> bool

Returns true if there are no handlers.

Trait Implementations

impl<E> Default for Broadcast<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E> Handler<E> for Broadcast<E>

fn run(&mut self, world: &mut World, event: E)

Run this handler with the given event.

fn name(&self) -> &'static str

Returns the handler’s name.