Struct bevy::ecs::removal_detection::RemovedComponentReader

pub struct RemovedComponentReader<T>
where
    T: Component,
{ /* private fields */ }

Wrapper around a ManualEventReader<RemovedComponentEntity> so that we can differentiate events between components.

Methods from Deref<Target = ManualEventReader<RemovedComponentEntity>>

pub fn read<'a>(&'a mut self, events: &'a Events<E>) -> EventIterator<'a, E>

See EventReader::read

Examples found in repository

examples/ecs/send_and_receive_events.rs (line 153)

fn send_and_receive_manual_event_reader(
    // The `Local` `SystemParam` stores state inside the system itself, rather than in the world.
    // `ManualEventReader<T>` is the internal state of `EventReader<T>`, which tracks which events have been seen.
    mut local_event_reader: Local<ManualEventReader<DebugEvent>>,
    // We can access the `Events` resource mutably, allowing us to both read and write its contents.
    mut events: ResMut<Events<DebugEvent>>,
    frame_count: Res<FrameCount>,
) {
    println!(
        "Sending and receiving events for frame {} with a `Local<ManualEventReader>",
        frame_count.0
    );

    // We must collect the events to resend, because we can't mutate events while we're iterating over the events.
    let mut events_to_resend = Vec::new();

    for event in local_event_reader.read(&events) {
        if event.resend_from_local_event_reader {
            // For simplicity, we're cloning the event.
            // In this case, since we have mutable access to the `Events` resource,
            // we could also just mutate the event in-place,
            // or drain the event queue into our `events_to_resend` vector.
            events_to_resend.push(event.clone());
        }
    }

    for mut event in events_to_resend {
        event.times_sent += 1;
        events.send(event);
    }
}

pub fn read_with_id<'a>( &'a mut self, events: &'a Events<E> ) -> EventIteratorWithId<'a, E>

See EventReader::read_with_id

pub fn len(&self, events: &Events<E>) -> usize

See EventReader::len

pub fn missed_events(&self, events: &Events<E>) -> usize

Amount of events we missed.

pub fn is_empty(&self, events: &Events<E>) -> bool

See EventReader::is_empty()

pub fn clear(&mut self, events: &Events<E>)

See EventReader::clear()

Trait Implementations

impl<T> Debug for RemovedComponentReader<T>

where T: Debug + Component,

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

Formats the value using the given formatter.

impl<T> Default for RemovedComponentReader<T>

where T: Component,

fn default() -> RemovedComponentReader<T>

Returns the “default value” for a type.

impl<T> Deref for RemovedComponentReader<T>

where T: Component,

type Target = ManualEventReader<RemovedComponentEntity>

The resulting type after dereferencing.

fn deref(&self) -> &<RemovedComponentReader<T> as Deref>::Target

Dereferences the value.

impl<T> DerefMut for RemovedComponentReader<T>

where T: Component,

fn deref_mut(&mut self) -> &mut <RemovedComponentReader<T> as Deref>::Target

Mutably dereferences the value.