Struct PopulatedMessageReader 

pub struct PopulatedMessageReader<'w, 's, M: Message>(/* private fields */);

Reads Messages of type T in order and tracks which messages have already been read. Skips the system if there no messages.

Use MessageReader<T> to run the system even if there are no messages.

Use the on_message run condition to skip the system based on messages that it doesn’t read.

Methods from Deref<Target = MessageReader<'w, 's, M>>

pub fn read(&mut self) -> MessageIterator<'_, M>

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

pub fn read_with_id(&mut self) -> MessageIteratorWithId<'_, M>

Like read, except also returning the MessageId of the messages.

pub fn par_read(&mut self) -> MessageParIter<'_, M>

Returns a parallel iterator over the messages this MessageReader has not seen yet. See also for_each.

Example

#[derive(Message)]
struct MyMessage {
    value: usize,
}

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

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

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

pub fn len(&self) -> usize

Determines the number of messages available to be read from this MessageReader without consuming any.

pub fn is_empty(&self) -> bool

Returns true if there are no messages available to read.

Example

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

#[derive(Message)]
struct Collision;

fn play_collision_sound(mut messages: MessageReader<Collision>) {
    if !messages.is_empty() {
        messages.clear();
        // Play a sound
    }
}

pub fn clear(&mut self)

Consumes all available messages.

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

For usage, see MessageReader::is_empty().

Trait Implementations

impl<'w, 's, M: Debug + Message> Debug for PopulatedMessageReader<'w, 's, M>

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

Formats the value using the given formatter.

impl<'w, 's, M: Message> Deref for PopulatedMessageReader<'w, 's, M>

type Target = MessageReader<'w, 's, M>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'w, 's, M: Message> DerefMut for PopulatedMessageReader<'w, 's, M>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'w, 's, M: Message> SystemParam for PopulatedMessageReader<'w, 's, M>

type State = <MessageReader<'w, 's, M> as SystemParam>::State

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

type Item<'world, 'state> = PopulatedMessageReader<'world, 'state, M>

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) -> Self::State

Creates a new instance of this param’s State.

fn init_access( state: &Self::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )

Registers any World access used by this SystemParam.

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

Creates a parameter to be passed into a SystemParamFunction.

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 ApplyDeferred.

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

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