Struct Events

pub struct Events<E: Event> { /* private fields */ }

An event collection that represents the events that occurred within the last two Events::update calls. Events can be written to using an EventWriter and are typically cheaply read using an EventReader.

Each event can be consumed by multiple systems, in parallel, with consumption tracked by the EventReader on a per-system basis.

If no ordering is applied between writing and reading systems, there is a risk of a race condition. This means that whether the events arrive before or after the next Events::update is unpredictable.

This collection is meant to be paired with a system that calls Events::update exactly once per update/frame.

event_update_system is a system that does this, typically initialized automatically using add_event. EventReaders are expected to read events from this collection at least once per loop/frame. Events will persist across a single frame boundary and so ordering of event producers and consumers is not critical (although poorly-planned ordering may cause accumulating lag). If events are not handled by the end of the frame after they are updated, they will be dropped silently.

Example

use bevy_ecs::event::{Event, Events};

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

// setup
let mut events = Events::<MyEvent>::default();
let mut cursor = events.get_cursor();

// run this once per update/frame
events.update();

// somewhere else: send an event
events.send(MyEvent { value: 1 });

// somewhere else: read the events
for event in cursor.read(&events) {
    assert_eq!(event.value, 1)
}

// events are only processed once per reader
assert_eq!(cursor.read(&events).count(), 0);

Details

Events is implemented using a variation of a double buffer strategy. Each call to update swaps buffers and clears out the oldest one.

• EventReaders will read events from both buffers.
• EventReaders that read at least once per update will never drop events.
• EventReaders that read once within two updates might still receive some events
• EventReaders that read after two updates are guaranteed to drop all events that occurred before those updates.

The buffers in Events will grow indefinitely if update is never called.

An alternative call pattern would be to call update manually across frames to control when events are cleared. This complicates consumption and risks ever-expanding memory usage if not cleaned up, but can be done by adding your event as a resource instead of using add_event.

Example usage. Example usage standalone.

Implementations

impl<E: Event> Events<E>

pub fn oldest_event_count(&self) -> usize

Returns the index of the oldest event stored in the event buffer.

pub fn send(&mut self, event: E) -> EventId<E>

“Sends” an event by writing it to the current event buffer. EventReaders can then read the event. This method returns the ID of the sent event.

pub fn send_batch( &mut self, events: impl IntoIterator<Item = E>, ) -> SendBatchIds<E>

Sends a list of events all at once, which can later be read by EventReaders. This is more efficient than sending each event individually. This method returns the IDs of the sent events.

pub fn send_default(&mut self) -> EventId<E>

where E: Default,

Sends the default value of the event. Useful when the event is an empty struct. This method returns the ID of the sent event.

pub fn get_cursor(&self) -> EventCursor<E>

Gets a new EventCursor. This will include all events already in the event buffers.

pub fn get_cursor_current(&self) -> EventCursor<E>

Gets a new EventCursor. This will ignore all events already in the event buffers. It will read all future events.

pub fn get_reader(&self) -> EventCursor<E>

👎Deprecated since 0.14.0: get_reader has been deprecated. Please use get_cursor instead.

Gets a new EventCursor. This will include all events already in the event buffers.

pub fn get_reader_current(&self) -> EventCursor<E>

👎Deprecated since 0.14.0: get_reader_current has been replaced. Please use get_cursor_current instead.

Gets a new EventCursor. This will ignore all events already in the event buffers. It will read all future events.

pub fn update(&mut self)

Swaps the event buffers and clears the oldest event buffer. In general, this should be called once per frame/update.

If you need access to the events that were removed, consider using Events::update_drain.

pub fn update_drain(&mut self) -> impl Iterator<Item = E> + '_

Swaps the event buffers and drains the oldest event buffer, returning an iterator of all events that were removed. In general, this should be called once per frame/update.

If you do not need to take ownership of the removed events, use Events::update instead.

pub fn clear(&mut self)

Removes all events.

pub fn len(&self) -> usize

Returns the number of events currently stored in the event buffer.

pub fn is_empty(&self) -> bool

Returns true if there are no events currently stored in the event buffer.

pub fn drain(&mut self) -> impl Iterator<Item = E> + '_

Creates a draining iterator that removes all events.

pub fn iter_current_update_events(&self) -> impl ExactSizeIterator<Item = &E>

Iterates over events that happened since the last “update” call. WARNING: You probably don’t want to use this call. In most cases you should use an EventReader. You should only use this if you know you only need to consume events between the last update() call and your call to iter_current_update_events. If events happen outside that window, they will not be handled. For example, any events that happen after this call and before the next update() call will be dropped.

pub fn get_event(&self, id: usize) -> Option<(&E, EventId<E>)>

Get a specific event by id if it still exists in the events buffer.

Trait Implementations

impl<E: Debug + Event> Debug for Events<E>

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

Formats the value using the given formatter.

impl<E: Event> Default for Events<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E: Event> Extend<E> for Events<E>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = E>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<E> FromReflect for Events<E>

where Events<E>: Any + Send + Sync, E: TypePath + Event, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl<E> GetTypeRegistration for Events<E>

where Events<E>: Any + Send + Sync, E: TypePath + Event, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl<E> PartialReflect for Events<E>

where Events<E>: Any + Send + Sync, E: TypePath + Event, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<E> Reflect for Events<E>

where Events<E>: Any + Send + Sync, E: TypePath + Event, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl<E> Struct for Events<E>

where Events<E>: Any + Send + Sync, E: TypePath + Event, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl<E> TypePath for Events<E>

where Events<E>: Any + Send + Sync, E: TypePath + Event,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl<E> Typed for Events<E>

where Events<E>: Any + Send + Sync, E: TypePath + Event, EventSequence<E>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, usize: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl<E: Event> Resource for Events<E>

where Self: Send + Sync + 'static,