Struct MapEffectLayer 

pub struct MapEffectLayer<Next, Effect>
where
    Next: Layer,
    Effect: 'static,
{ /* private fields */ }

Middleware for converting the effect type to another type.

Typically, this is used to eliminate some of the effect variants which are processed by the layers below, so that code using this stack is not forced to have extraneous match arms which are never called.

Implementations

impl<Next, Effect> MapEffectLayer<Next, Effect>

where Next: Layer,

pub fn new(next: Next) -> Self

Trait Implementations

impl<Next, Effect> Layer for MapEffectLayer<Next, Effect>

where Next: Layer, Effect: From<Next::Effect> + Send + 'static,

type Event = <Next as Layer>::Event

Event type expected by this layer

type Effect = Effect

Effect type returned by this layer

type ViewModel = <Next as Layer>::ViewModel

ViewModel returned by this layer

fn update<F>(&self, event: Self::Event, effect_callback: F) -> Vec<Self::Effect>

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

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>( &self, request: &mut impl Resolvable<Output>, output: Output, effect_callback: F, ) -> Result<Vec<Self::Effect>, ResolveError>

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

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>,