Struct EventMut

pub struct EventMut<'a, E>
where
    E: Event,
{ /* private fields */ }

Mutable reference to an instance of event E.

To get at E, use the Deref and DerefMut implementations or take.

Implementations

impl<'a, E> EventMut<'a, E>

where E: Event,

pub fn take(this: EventMut<'a, E>) -> E

Takes ownership of the event. Any handlers expected to run after the current handler will not run.

Examples

world.add_handler(|r: ReceiverMut<E>| {
    EventMut::take(r.event); // Took ownership of event.
});

world.add_handler(|_: Receiver<E>| panic!("boom"));

world.send(E);
// ^ No panic occurs because the first handler took
// ownership of the event before the second could run.

Trait Implementations

impl<'a, E> Debug for EventMut<'a, E>

where E: Event, <E as Event>::This<'a>: Debug,

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

Formats the value using the given formatter.

impl<'a, E> Deref for EventMut<'a, E>

where E: Event,

type Target = <E as Event>::This<'a>

The resulting type after dereferencing.

fn deref(&self) -> &<EventMut<'a, E> as Deref>::Target

Dereferences the value.

impl<E> DerefMut for EventMut<'_, E>

where E: Event,

fn deref_mut(&mut self) -> &mut <EventMut<'_, E> as Deref>::Target

Mutably dereferences the value.

impl<'a, E> Send for EventMut<'a, E>

where E: Event, <E as Event>::This<'a>: Send,

impl<'a, E> Sync for EventMut<'a, E>

where E: Event, <E as Event>::This<'a>: Sync,