Struct EventReader

pub struct EventReader<'w, 's, E: Event> { /* private fields */ }

Reads events of type T in order and tracks which events have already been read.

Concurrency

Unlike EventWriter<T>, systems with EventReader<T> param can be executed concurrently (but not concurrently with EventWriter<T> systems for the same event type).

Implementations

impl<'w, 's, E: Event> EventReader<'w, 's, E>

pub fn read(&mut self) -> EventIterator<'_, E>

Iterates over the events this EventReader has not seen yet. This updates the EventReader’s event counter, which means subsequent event reads will not include events that happened before now.

pub fn read_with_id(&mut self) -> EventIteratorWithId<'_, E>

Like read, except also returning the EventId of the events.

pub fn par_read(&mut self) -> EventParIter<'_, E>

Returns a parallel iterator over the events this EventReader has not seen yet. See also for_each.

Example

#[derive(Event)]
struct MyEvent {
    value: usize,
}

#[derive(Resource, Default)]
struct Counter(AtomicUsize);

// setup
let mut world = World::new();
world.init_resource::<Events<MyEvent>>();
world.insert_resource(Counter::default());

let mut schedule = Schedule::default();
schedule.add_systems(|mut events: EventReader<MyEvent>, counter: Res<Counter>| {
    events.par_read().for_each(|MyEvent { value }| {
        counter.0.fetch_add(*value, Ordering::Relaxed);
    });
});
for value in 0..100 {
    world.send_event(MyEvent { value });
}
schedule.run(&mut world);
let Counter(counter) = world.remove_resource::<Counter>().unwrap();
// all events were processed
assert_eq!(counter.into_inner(), 4950);

pub fn len(&self) -> usize

Determines the number of events available to be read from this EventReader without consuming any.

pub fn is_empty(&self) -> bool

Returns true if there are no events available to read.

Example

The following example shows a useful pattern where some behavior is triggered if new events are available. EventReader::clear() is used so the same events don’t re-trigger the behavior the next time the system runs.

#[derive(Event)]
struct CollisionEvent;

fn play_collision_sound(mut events: EventReader<CollisionEvent>) {
    if !events.is_empty() {
        events.clear();
        // Play a sound
    }
}

pub fn clear(&mut self)

Consumes all available events.

This means these events will not appear in calls to EventReader::read() or EventReader::read_with_id() and EventReader::is_empty() will return true.

For usage, see EventReader::is_empty().

Trait Implementations

impl<'w, 's, E: Debug + Event> Debug for EventReader<'w, 's, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E: Event> SystemParam for EventReader<'_, '_, E>

type State = FetchState<E>

Used to store data which persists across invocations of a system.

type Item<'w, 's> = EventReader<'w, 's, E>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.

unsafe fn new_archetype( state: &mut Self::State, archetype: &Archetype, system_meta: &mut SystemMeta, )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).a

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during apply_deferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next apply_deferred.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

impl<'w, 's, E: Event> ReadOnlySystemParam for EventReader<'w, 's, E>

where Local<'s, ManualEventReader<E>>: ReadOnlySystemParam, Res<'w, Events<E>>: ReadOnlySystemParam,