Struct CatchAssertUnwindSafe 

pub struct CatchAssertUnwindSafe<H> { /* private fields */ }

Panic-catching wrapper for Handler implementations.

Catches panics during run() so the handler is never lost during move-out-fire dispatch. This is an annotation — wrap a concrete handler, then virtualize through your chosen storage (Box, Flat, Flex, typed slab, etc.).

By constructing this wrapper, the user asserts that the inner handler (and any World resources it mutates) can tolerate partial writes caused by an unwound run() call. This is the same assertion as std::panic::AssertUnwindSafe, applied at the handler level.

Examples

use nexus_rt::{CatchAssertUnwindSafe, WorldBuilder, ResMut, IntoHandler, Handler, Virtual, Resource};

#[derive(Resource)]
struct Counter(u64);

fn tick(mut counter: ResMut<Counter>, event: u32) {
    counter.0 += event as u64;
}

let mut builder = WorldBuilder::new();
builder.register(Counter(0));
let mut world = builder.build();

let handler = tick.into_handler(world.registry());
let guarded = CatchAssertUnwindSafe::new(handler);
let mut boxed: Virtual<u32> = Box::new(guarded);

boxed.run(&mut world, 10);
assert_eq!(world.resource::<Counter>().0, 10);

Implementations

impl<H> CatchAssertUnwindSafe<H>

pub fn new(handler: H) -> Self

Wrap a handler with panic catching.

The caller asserts that the handler and any resources it touches are safe to continue using after a caught panic.

pub fn panic_count(&self) -> u64

Number of panics caught since construction.

Poll this periodically in health checks to detect handlers that are silently failing. A non-zero value means the handler panicked at least once — investigate the root cause.

Trait Implementations

impl<E, H: Handler<E>> Handler<E> for CatchAssertUnwindSafe<H>

fn run(&mut self, world: &mut World, event: E)

Run this handler with the given event.

fn name(&self) -> &'static str

Returns the handler’s name.