Struct Store

pub struct Store<State, Action, RootReducer>
where
    State: Send,
    RootReducer: Send,
{ /* private fields */ }

The store is the heart of any redux application, it contains the state of the application.

The state of the store can be modified by dispatching actions to it. Updates to the state can be observed by subscribing to the store or by writing middleware. Getting a part of the store or the full store is possible with the select and state_cloned methods.

Implementations

impl<State, Action, RootReducer> Store<State, Action, RootReducer>

where Action: Send + 'static, RootReducer: Reducer<State, Action> + Send + 'static, State: Send + 'static,

pub fn new(root_reducer: RootReducer) -> Self

where State: Default,

Create a new store with the given root reducer and default state

pub fn new_with_state(root_reducer: RootReducer, state: State) -> Self

Create a new store with the given root reducer and the provided state

pub async fn dispatch(&self, action: Action)

Dispatch a new action to the store

Notice that this method takes &self and not &mut self, this enables us to dispatch actions from multiple places at once without requiring locks.

pub async fn select<S, Result>(&self, selector: S) -> Result

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

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.

pub async fn state_cloned(&self) -> State

where State: Clone,

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

pub async fn subscribe<S: Subscriber<State> + Send + 'static>( &self, subscriber: S, )

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

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

where M: MiddleWare<State, OuterAction, Self, Action> + Send + Sync, OuterAction: Send + Sync + 'static, State: Sync, Action: Sync, RootReducer: Sync,

Wrap the store with middleware, see middleware module for more examples

Trait Implementations

impl<State, Action, RootReducer> StoreApi<State, Action> for Store<State, Action, RootReducer>

where Action: Send + Sync + 'static, RootReducer: Reducer<State, Action> + Send + Sync + 'static, State: Send + Sync + 'static,

fn dispatch<'life0, 'async_trait>( &'life0 self, action: Action, ) -> 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 state_cloned<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = State> + Send + 'async_trait>>

where State: Clone, Self: '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

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