Struct EventTrigger 

pub struct EventTrigger { /* private fields */ }

The sending half of a manual event. Call fire to wake all processes currently waiting on the paired EventAwaitable, and to make any future awaits on that same awaitable resolve immediately.

Dropping a trigger without firing it strands its waiters. If an EventTrigger is dropped without fire() being called, the event never fires: any process currently awaiting the paired EventAwaitable — and any that awaits it later — will suspend forever (until the run ends and SimEnv’s Drop reclaims the suspended processes). This is a normal discrete-event outcome (a signal that simply never arrives), not a panic; if a process must not block indefinitely, race the awaitable against a timeout via any_of!.

One trigger, many waiters — including one that only starts waiting after the fire (the latch makes it resolve immediately):

use simu::SimEnv;

let mut env = SimEnv::with_seed(0);
let (trigger, ready) = env.event();

// Fires at t = 2.
let h = env.handle();
env.spawn(async move {
    h.timeout(2.0).await;
    trigger.fire(); // consumes the trigger — an event fires at most once
});

// Suspends now, woken at t = 2.
let r = ready.clone(); // Clone = same underlying event
let h1 = env.handle();
env.spawn(async move {
    r.await;
    assert_eq!(h1.now(), 2.0);
});

// Starts waiting at t = 3 — after the fire — and resolves immediately.
let h2 = env.handle();
env.spawn(async move {
    h2.timeout(3.0).await;
    ready.await; // already fired: no suspension
    assert_eq!(h2.now(), 3.0);
});

env.run();

Implementations

impl EventTrigger

pub fn fire(self)

Fire the event.

All processes currently suspended on the paired EventAwaitable are woken immediately. Any process that awaits the event after this call will also resolve without suspending.

Trait Implementations

impl Debug for EventTrigger

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

Formats the value using the given formatter.