Struct MessageCursor 

pub struct MessageCursor<E>
where
    E: Message,
{ /* private fields */ }

Stores the state for a MessageReader or MessageMutator.

Access to the Messages<E> resource is required to read any incoming messages.

In almost all cases, you should just use a MessageReader or MessageMutator, which will automatically manage the state for you.

However, this type can be useful if you need to manually track messages, such as when you’re attempting to send and receive messages of the same type in the same system.

Example

use bevy_ecs::prelude::*;
use bevy_ecs::message::{Message, MessageCursor};

#[derive(Message, Clone, Debug)]
struct MyMessage;

/// A system that both sends and receives messages using a [`Local`] [`MessageCursor`].
fn send_and_receive_messages(
    // The `Local` `SystemParam` stores state inside the system itself, rather than in the world.
    // `MessageCursor<T>` is the internal state of `MessageMutator<T>`, which tracks which messages have been seen.
    mut local_message_reader: Local<MessageCursor<MyMessage>>,
    // We can access the `Messages` resource mutably, allowing us to both read and write its contents.
    mut messages: ResMut<Messages<MyMessage>>,
) {
    // We must collect the messages to resend, because we can't mutate messages while we're iterating over the messages.
    let mut messages_to_resend = Vec::new();

    for message in local_message_reader.read(&mut messages) {
         messages_to_resend.push(message.clone());
    }

    for message in messages_to_resend {
        messages.write(MyMessage);
    }
}

Implementations

impl<E> MessageCursor<E>

where E: Message,

pub fn read<'a>( &'a mut self, messages: &'a Messages<E>, ) -> MessageIterator<'a, E>

See MessageReader::read

pub fn read_mut<'a>( &'a mut self, messages: &'a mut Messages<E>, ) -> MessageMutIterator<'a, E>

See MessageMutator::read

pub fn read_with_id<'a>( &'a mut self, messages: &'a Messages<E>, ) -> MessageIteratorWithId<'a, E>

See MessageReader::read_with_id

pub fn read_mut_with_id<'a>( &'a mut self, messages: &'a mut Messages<E>, ) -> MessageMutIteratorWithId<'a, E>

See MessageMutator::read_with_id

pub fn par_read<'a>( &'a mut self, messages: &'a Messages<E>, ) -> MessageParIter<'a, E>

See MessageReader::par_read

pub fn par_read_mut<'a>( &'a mut self, messages: &'a mut Messages<E>, ) -> MessageMutParIter<'a, E>

See MessageMutator::par_read

pub fn len(&self, messages: &Messages<E>) -> usize

See MessageReader::len

pub fn missed_messages(&self, messages: &Messages<E>) -> usize

Amount of messages we missed.

pub fn is_empty(&self, messages: &Messages<E>) -> bool

See MessageReader::is_empty()

pub fn clear(&mut self, messages: &Messages<E>)

See MessageReader::clear()

Trait Implementations

impl<E> Clone for MessageCursor<E>

where E: Message,

fn clone(&self) -> MessageCursor<E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E> Debug for MessageCursor<E>

where E: Debug + Message,

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

Formats the value using the given formatter.

impl<E> Default for MessageCursor<E>

where E: Message,

fn default() -> MessageCursor<E>

Returns the “default value” for a type.