Struct EffectRouter 

pub struct EffectRouter<App, RouteSet>
where
    App: App,
{
    pub routes: RouteSet,
    /* private fields */
}

Wraps a Core and routes each emitted effect to a type-specific handler.

The router owns the set of routes (RouteSet) and a routing closure which decides, per effect, which handler should process it. Any follow-up effects produced while resolving a request are passed back through the same closure, so routing decisions stay consistent across an entire chain of effects.

Construct one with EffectRouter::new. The router is always held behind an Arc so that individual routes can keep a Weak reference back to it and drive the runtime forward when they resolve requests.

Fields

routes: RouteSet

The set of handlers effects are routed to.

Exposed so the surrounding FFI type can reach individual routes (for example to resolve a parked or serialized request by id).

Implementations

impl<App, RouteSet> EffectRouter<App, RouteSet>

where App: App, RouteSet: Routes<App> + Send + Sync + 'static,

pub fn new<F, R>(core: Core<App>, route_effects_builder: F) -> Arc<Self>

where F: FnOnce(RouteSet) -> R, R: Fn(App::Effect) + Send + Sync + 'static,

Create a new router wrapping core.

The route set is constructed first (via Routes::new) and then passed to route_effects_builder, which returns the routing closure. Splitting construction this way lets the closure capture the routes it needs to dispatch to, while the routes themselves hold a Weak reference back to the router so they can resolve requests later.

The router is returned inside an Arc because that shared ownership is what the routes’ weak references point at; see Arc::new_cyclic.

pub fn update(&self, event: App::Event)

Process an event from the shell and route every resulting effect.

This is the router’s equivalent of Core::process_event: it forwards the event to the wrapped core and passes each emitted effect through the routing closure.

pub fn resolve<Output>( &self, request: &mut impl Resolvable<Output>, output: Output, ) -> Result<(), ResolveError>

Resolve an effect Request with an output value.

Errors

Returns an error if the request is not expected to be resolved by the underlying Core.

pub fn view(&self) -> App::ViewModel

Return the current view model from the wrapped Core.

Trait Implementations

impl<App, RouteSet, Op> ResolveSink<Op> for EffectRouter<App, RouteSet>

where App: App, RouteSet: Routes<App> + Send + Sync + 'static, Op: Operation,

fn resolve_request( &self, request: &mut Request<Op>, output: Op::Output, ) -> Result<(), ResolveError>

Resolve a Request with an output value and advance the runtime.