Struct Emitter 

pub struct Emitter<Event>(/* private fields */);

Event emitter that can be embedded in Props.

Clone this handle to create callbacks in your Props that can trigger events when invoked (e.g., by user interaction).

Emitter uses interior mutability via Arc<Mutex<...>>, making it cheap to clone (just an atomic reference count increment) and thread-safe.

Example

use oxide_mvu::{Emitter, MvuLogic, Effect};

enum Event { Click }

#[derive(Clone)]
struct Model { clicks: u32 }

struct Props {
    clicks: u32,
    on_click: Box<dyn Fn()>,
}

struct MyApp;

impl MvuLogic<Event, Model, Props> for MyApp {
    fn init(&self, model: Model) -> (Model, Effect<Event>) {
        (model, Effect::none())
    }

    fn update(&self, event: Event, model: &Model) -> (Model, Effect<Event>) {
        match event {
            Event::Click => {
                let new_model = Model {
                    clicks: model.clicks + 1,
                    ..model.clone()
                };
                (new_model, Effect::none())
            }
        }
    }

    fn view(&self, model: &Model, emitter: &Emitter<Event>) -> Props {
        let emitter = emitter.clone();
        Props {
            clicks: model.clicks,
            on_click: Box::new(move || {
                emitter.emit(Event::Click);
            }),
        }
    }
}

Implementations

impl<Event> Emitter<Event>

pub fn new<F: FnMut(Event) + Send + 'static>(f: F) -> Self

Create a new emitter from a callback function.

The callback will be invoked when emit is used.

pub fn emit(&self, event: Event)

Emit an event.

This queues the event for processing by the runtime. Multiple threads can safely call this method concurrently.

Trait Implementations

impl<Event> Clone for Emitter<Event>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.