Struct HandlerTemplate 

pub struct HandlerTemplate<K: Blueprint>
where
    <K::Params as Param>::State: Copy,
{ /* private fields */ }

Resolve-once template for context-free handlers.

Created from a named function + Registry. Calling generate stamps out TemplatedHandlers by copying pre-resolved state — no registry lookups, no validation.

Examples

use nexus_rt::{WorldBuilder, ResMut, Handler};
use nexus_rt::template::{Blueprint, HandlerTemplate};

struct OnTick;
impl Blueprint for OnTick {
    type Event = u32;
    type Params = (ResMut<'static, u64>,);
}

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

let mut builder = WorldBuilder::new();
builder.register::<u64>(0);
let world = builder.build();

let template = HandlerTemplate::<OnTick>::new(tick, world.registry());

let mut h1 = template.generate();
let mut h2 = template.generate();

// Both share pre-resolved ResourceIds — no redundant lookups.

Implementations

impl<K: Blueprint> HandlerTemplate<K>

where <K::Params as Param>::State: Copy,

pub fn new<F>(f: F, registry: &Registry) -> Self

where F: TemplateDispatch<K::Params, K::Event>,

Create a template from a named function.

Resolves all parameters from the registry and validates access. F must be a ZST (named function item) — closures and function pointers are rejected at compile time.

Panics

• If any required resource is not registered.
• If params have conflicting access (same resource twice).

pub fn generate(&self) -> TemplatedHandler<K>

Stamp out a new handler by copying pre-resolved state.