pub struct MessageMutator<'w, 's, E: Message> { /* private fields */ }
Expand description
Mutably reads messages of type T
keeping track of which messages have already been read
by each system allowing multiple systems to read the same messages. Ideal for chains of systems
that all want to modify the same messages.
§Usage
MessageMutator
s are usually declared as a SystemParam
.
#[derive(Message, Debug)]
pub struct MyMessage(pub u32); // Custom message type.
fn my_system(mut reader: MessageMutator<MyMessage>) {
for message in reader.read() {
message.0 += 1;
println!("received message: {:?}", message);
}
}
§Concurrency
Multiple systems with MessageMutator<T>
of the same message type can not run concurrently.
They also can not be executed in parallel with MessageReader
or MessageWriter
.
§Clearing, Reading, and Peeking
Messages are stored in a double buffered queue that switches each frame. This switch also clears the previous
frame’s messages. Messages should be read each frame otherwise they may be lost. For manual control over this
behavior, see Messages
.
Most of the time systems will want to use MessageMutator::read()
. This function creates an iterator over
all messages that haven’t been read yet by this system, marking the message as read in the process.
Implementations§
Source§impl<'w, 's, E: Message> MessageMutator<'w, 's, E>
impl<'w, 's, E: Message> MessageMutator<'w, 's, E>
Sourcepub fn read(&mut self) -> MessageMutIterator<'_, E> ⓘ
pub fn read(&mut self) -> MessageMutIterator<'_, E> ⓘ
Iterates over the messages this MessageMutator
has not seen yet. This updates the
MessageMutator
’s message counter, which means subsequent message reads will not include messages
that happened before now.
Sourcepub fn read_with_id(&mut self) -> MessageMutIteratorWithId<'_, E> ⓘ
pub fn read_with_id(&mut self) -> MessageMutIteratorWithId<'_, E> ⓘ
Sourcepub fn par_read(&mut self) -> MessageMutParIter<'_, E>
pub fn par_read(&mut self) -> MessageMutParIter<'_, E>
Returns a parallel iterator over the messages this MessageMutator
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: MessageMutator<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);
Sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Determines the number of messages available to be read from this MessageMutator
without consuming any.
Sourcepub fn is_empty(&self) -> bool
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.
MessageMutator::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: MessageMutator<Collision>) {
if !messages.is_empty() {
messages.clear();
// Play a sound
}
}
Sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Consumes all available messages.
This means these messages will not appear in calls to MessageMutator::read()
or
MessageMutator::read_with_id()
and MessageMutator::is_empty()
will return true
.
For usage, see MessageMutator::is_empty()
.
Trait Implementations§
Source§impl<E: Message> SystemParam for MessageMutator<'_, '_, E>
impl<E: Message> SystemParam for MessageMutator<'_, '_, E>
Source§type Item<'w, 's> = MessageMutator<'w, 's, E>
type Item<'w, 's> = MessageMutator<'w, 's, E>
Self
, instantiated with new lifetimes. Read moreSource§fn init_access(
state: &Self::State,
system_meta: &mut SystemMeta,
component_access_set: &mut FilteredAccessSet,
world: &mut World,
)
fn init_access( state: &Self::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )
World
access used by this SystemParam
Source§fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)
fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)
SystemParam
’s state.
This is used to apply Commands
during ApplyDeferred
.Source§fn queue(
state: &mut Self::State,
system_meta: &SystemMeta,
world: DeferredWorld<'_>,
)
fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )
ApplyDeferred
.Source§unsafe fn validate_param<'w, 's>(
state: &'s mut Self::State,
_system_meta: &SystemMeta,
_world: UnsafeWorldCell<'w>,
) -> Result<(), SystemParamValidationError>
unsafe fn validate_param<'w, 's>( state: &'s mut Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>
Source§unsafe fn get_param<'w, 's>(
state: &'s mut Self::State,
system_meta: &SystemMeta,
world: UnsafeWorldCell<'w>,
change_tick: Tick,
) -> Self::Item<'w, 's>
unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Self::Item<'w, 's>
SystemParamFunction
. Read moreimpl<'w, 's, E: Message> ReadOnlySystemParam for MessageMutator<'w, 's, E>where
Local<'s, MessageCursor<E>>: ReadOnlySystemParam,
ResMut<'w, Messages<E>>: ReadOnlySystemParam,
Auto Trait Implementations§
impl<'w, 's, E> Freeze for MessageMutator<'w, 's, E>
impl<'w, 's, E> RefUnwindSafe for MessageMutator<'w, 's, E>where
E: RefUnwindSafe,
impl<'w, 's, E> Send for MessageMutator<'w, 's, E>
impl<'w, 's, E> Sync for MessageMutator<'w, 's, E>
impl<'w, 's, E> Unpin for MessageMutator<'w, 's, E>
impl<'w, 's, E> !UnwindSafe for MessageMutator<'w, 's, E>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
, which can then be
downcast
into Box<dyn ConcreteType>
where ConcreteType
implements Trait
.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
, which can then be further
downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.