Struct bevy::ecs::event::EventReader

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

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

Implementations

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

pub fn iter(&mut self) -> ManualEventIterator<'_, 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 iter_with_id(&mut self) -> ManualEventIteratorWithId<'_, E>

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

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 behaviour is triggered if new events are available. EventReader::clear() is used so the same events don’t re-trigger the behaviour the next time the system runs.

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::iter() or EventReader::iter_with_id() and EventReader::is_empty() will return true.

For usage, see EventReader::is_empty().

Trait Implementations

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

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

Formats the value using the given formatter.

impl<'a, 'w, 's, E> IntoIterator for &'a mut EventReader<'w, 's, E>where E: Event,

type Item = &'a E

The type of the elements being iterated over.

type IntoIter = ManualEventIterator<'a, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut EventReader<'w, 's, E> as IntoIterator>::IntoIter

Creates an iterator from a value.

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

type State = FetchState<'static, 'static, E>

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

type Item = 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 ) -> <EventReader<'w, 's, E> as SystemParam>::State

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

fn new_archetype( state: &mut <EventReader<'w, 's, E> as SystemParam>::State, archetype: &Archetype, system_meta: &mut SystemMeta )

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

fn apply( state: &mut <EventReader<'w, 's, E> as SystemParam>::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_system_buffers.

unsafe fn get_param<'w2, 's2>( state: &'s2 mut <EventReader<'w, 's, E> as SystemParam>::State, system_meta: &SystemMeta, world: &'w2 World, change_tick: u32 ) -> <EventReader<'w, 's, E> as SystemParam>::Item<'w2, 's2>

Safety

impl<'w, 's, E> ReadOnlySystemParam for EventReader<'w, 's, E>where E: Event, Local<'s, ManualEventReader<E>>: ReadOnlySystemParam, Res<'w, Events<E>>: ReadOnlySystemParam,