Struct Owned 

pub struct Owned<H, E: ?Sized> { /* private fields */ }

Reference-to-owned adapter via ToOwned. Wraps a Handler<E::Owned> and implements Handler<&E> — the event is converted via to_owned() before dispatch.

More general than Cloned: handles &str → String, &[u8] → Vec<u8>, and any other ToOwned impl where the owned type differs from the reference target. For T: Clone, ToOwned is blanket-implemented with Owned = T, so this adapter also works as a drop-in replacement for Cloned in those cases.

E must be named explicitly because the ToOwned mapping is not invertible — given Handler<String>, the compiler cannot infer that E = str. Use Owned::new with turbofish when needed. For simple Clone types where E = E::Owned, prefer Cloned.

Examples

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

#[derive(Resource)]
struct Buffer(String);

fn process(mut buf: ResMut<Buffer>, event: String) {
    buf.0.push_str(&event);
}

let mut builder = WorldBuilder::new();
builder.register(Buffer(String::new()));
let mut world = builder.build();

let h = process.into_handler(world.registry());
let mut adapted = Owned::<_, str>::new(h);
adapted.run(&mut world, "hello");
assert_eq!(world.resource::<Buffer>().0.as_str(), "hello");

Implementations

impl<H, E: ?Sized> Owned<H, E>

pub fn new(handler: H) -> Self

Create a new Owned adapter.

When E cannot be inferred, use turbofish: Owned::<_, str>::new(handler).

Trait Implementations

impl<'e, E, H> Handler<&'e E> for Owned<H, E>

where E: ToOwned + 'e + ?Sized, H: Handler<E::Owned> + Send,

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

Run this handler with the given event.

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

Returns the handler’s name.