Struct StoreWithMiddleware

pub struct StoreWithMiddleware<Inner, M, State, InnerAction, OuterAction>
where
    Inner: StoreApi<State, InnerAction> + Send + Sync,
    M: MiddleWare<State, OuterAction, Inner, InnerAction> + Send + Sync,
    State: Send + Sync + 'static,
    InnerAction: Send + Sync + 'static,
    OuterAction: Send + Sync + 'static,
{ /* private fields */ }

Store which ties an underlying store and middleware together.

Implementations

impl<Inner, M, State, InnerAction, OuterAction> StoreWithMiddleware<Inner, M, State, InnerAction, OuterAction>

where Inner: StoreApi<State, InnerAction> + Send + Sync, M: MiddleWare<State, OuterAction, Inner, InnerAction> + Send + Sync, State: Send + Sync + 'static, InnerAction: Send + Sync + 'static, OuterAction: Send + Sync + 'static,

pub async fn wrap<MNew, NewOuterAction>( self, middleware: MNew, ) -> StoreWithMiddleware<Self, MNew, State, OuterAction, NewOuterAction>

where MNew: MiddleWare<State, NewOuterAction, Self, OuterAction> + Send + Sync, NewOuterAction: Send + Sync + 'static, State: Sync,

Wrap the store with middleware

Trait Implementations

impl<Inner, M, State, InnerAction, OuterAction> StoreApi<State, OuterAction> for StoreWithMiddleware<Inner, M, State, InnerAction, OuterAction>

where Inner: StoreApi<State, InnerAction> + Send + Sync, M: MiddleWare<State, OuterAction, Inner, InnerAction> + Send + Sync, State: Send + Sync + 'static, InnerAction: Send + Sync + 'static, OuterAction: Send + Sync + 'static,

fn dispatch<'life0, 'async_trait>( &'life0 self, action: OuterAction, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Dispatch a new action to the store

fn select<'life0, 'async_trait, S, Result>( &'life0 self, selector: S, ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where S: Selector<State, Result = Result> + Send + 'static + 'async_trait, Result: Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Select a part of the state, this is more efficient than copying the entire state all the time. In case you still need a full copy of the state, use the state_cloned method.

fn subscribe<'life0, 'async_trait, S>( &'life0 self, subscriber: S, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where S: 'async_trait + Subscriber<State> + Send + 'static, Self: 'async_trait, 'life0: 'async_trait,

Subscribe to state changes. Every time an action is dispatched the subscriber will be notified after the state is updated

fn state_cloned<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = State> + Send + 'async_trait>>

where State: Clone, Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns a cloned version of the state. This is not efficient, if you only need a part of the state use select instead