Struct Handler 

pub struct Handler<'ctx, D, T, Msg>
where
    D: MessageMapper<Msg, T>,
{ /* private fields */ }

Provides the necessary wiring for a centralized state handling mechanism. The API guides you along handling the lifetimes properly as well as registering all the state management logic in one place.

Implementations

impl<'ctx, D, T, Msg> Handler<'ctx, D, T, Msg>

where D: MessageMapper<Msg, T>,

pub fn new(cx: Scope<'ctx>, initial: T, dispatcher: D) -> &'ctx Self

Constructs a new Handler with a lifetime anchored to the provided Scope. You will usually construct this in your top level scope and then pass the handlers down into your components.

pub fn dispatch(&'ctx self, cx: Scope<'ctx>, msg: Msg)

Directly handle a state message without requiring a binding.

pub fn read_signal(&'ctx self) -> &'ctx ReadSignal<T>

Provides a ReadSignal handle for the contained Signal implementation.

pub fn bind_trigger<F, Val>( &'ctx self, cx: Scope<'ctx>, trigger: &'ctx ReadSignal<Val>, message_fn: F, )

where F: Fn(Rc<Val>) -> Msg + 'ctx,

Binds a triggering signal and associated message mapping function as a state update for this Handler instance. This uses create_effect so be aware that it will fire at least once when you first call it. It is really easy to introduce an infinite signal update loop.

pub fn get_selector<F, Val>( &'ctx self, cx: Scope<'ctx>, selector_factory: F, ) -> &'ctx ReadSignal<Val>

where F: Fn(&'ctx ReadSignal<T>) -> Val + 'ctx, Val: PartialEq,

Helper method to get a memoized value derived from the contained state for this Handler. The provided handler only notifies subscribers If the state has actually been updated.

pub fn get_value<F, Val>(&'ctx self, getter_factory: F) -> Val

where F: Fn(&'ctx ReadSignal<T>) -> Val + 'ctx,