MessageMutator

Struct MessageMutator 

Source
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

MessageMutators 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>

Source

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.

Source

pub fn read_with_id(&mut self) -> MessageMutIteratorWithId<'_, E>

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

Source

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);
Source

pub fn len(&self) -> usize

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

Source

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
    }
}
Source

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<'w, 's, E: Debug + Message> Debug for MessageMutator<'w, 's, E>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<E: Message> SystemParam for MessageMutator<'_, '_, E>

Source§

type State = FetchState<E>

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

type Item<'w, 's> = MessageMutator<'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. Read more
Source§

fn init_state(world: &mut World) -> Self::State

Creates a new instance of this param’s State.
Source§

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
Source§

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.
Source§

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

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

unsafe fn validate_param<'w, 's>( state: &'s mut Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param. Read more
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>

Creates a parameter to be passed into a SystemParamFunction. Read more
Source§

impl<'w, 's, E: Message> ReadOnlySystemParam for MessageMutator<'w, 's, E>

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> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

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

Converts 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>

Converts 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)

Converts &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)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoResult<T> for T

Source§

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
Source§

impl<A> Is for A
where A: Any,

Source§

fn is<T>() -> bool
where T: Any,

Checks if the current type “is” another type, using a TypeId equality comparison. This is most useful in the context of generic logic. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ConditionalSend for T
where T: Send,