Struct HandleEffectLayer 

pub struct HandleEffectLayer<Next, EM>
where
    Next: Layer + Sync + Send + 'static,
    Next::Effect: TryInto<Request<EM::Op>, Error = Next::Effect>,
    EM: EffectMiddleware,
{ /* private fields */ }

Middleware layer able to process some of the effects. This implements the general behaviour making sure all follow-up effects are processed and routed to the right place and delegates to the generic parameter EM, which implements EffectMiddleware.

Implementations

impl<Next, EM> HandleEffectLayer<Next, EM>

where Next: Layer, Next::Effect: TryInto<Request<EM::Op>, Error = Next::Effect>, EM: EffectMiddleware + 'static,

pub fn new(next: Next, middleware: EM) -> Self

Typically, you would use Layer::handle_effects_using to construct a HandleEffectLayer instance for a specific EffectMiddleware.

Trait Implementations

impl<Next, EM> Layer for HandleEffectLayer<Next, EM>

where Next: Layer, Next::Effect: TryInto<Request<EM::Op>, Error = Next::Effect>, EM: EffectMiddleware + 'static,

type Event = <Next as Layer>::Event

Event type expected by this layer

type Effect = <Next as Layer>::Effect

Effect type returned by this layer

type ViewModel = <Next as Layer>::ViewModel

ViewModel returned by this layer

fn update<F: Fn(Vec<Self::Effect>) + Send + Sync + 'static>( &self, event: Self::Event, effect_callback: F, ) -> Vec<Self::Effect>

Process event from the Shell. Compared to Core::process_event this expects an additional argument - a callback to be called with effects requested outside of the initial call context.

fn resolve<Output, F: Fn(Vec<Self::Effect>) + Send + Sync + 'static>( &self, request: &mut impl Resolvable<Output>, output: Output, effect_callback: F, ) -> Result<Vec<Self::Effect>, ResolveError>

Resolve a requested effect. Compared to Core::process_event this expects an additional argument - a callback to be called with effects requested outside of the initial call context.

fn view(&self) -> Self::ViewModel

Return the current state of the view model

fn process_tasks<F>(&self, effect_callback: F) -> Vec<Self::Effect>

where F: Fn(Vec<Self::Effect>) + Sync + Send + 'static,

Process any tasks in the effect runtime of the Core, which are able to proceed. The tasks may produce effects which will be returned by the core and may be processed by lower middleware layers.

fn handle_effects_using<EM>(self, middleware: EM) -> HandleEffectLayer<Self, EM>

where EM: EffectMiddleware + 'static, Self::Effect: TryInto<Request<EM::Op>, Error = Self::Effect>,

Wrap this layer with an effect handling middleware. The middleware argument must implement the EffectMiddleware trait.

fn map_effect<NewEffect>(self) -> MapEffectLayer<Self, NewEffect>

where NewEffect: From<Self::Effect> + Send + 'static,

Wrap this layer with an effect mapping middleware to change the Effect type returned.

fn bridge<Format: FfiFormat>( self, effect_callback: impl Fn(Result<Vec<u8>, BridgeError<Format>>) + Send + Sync + 'static, ) -> Bridge<Self, Format>

where Self::Effect: EffectFFI, Self::Event: for<'a> Deserialize<'a>,