Struct redux_rs::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: Selector<State, Result = Result>, 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
    'life0: 'async_trait,
    Self: 'async_trait, 

Dispatch a new action to the store

fn select<'life0, 'async_trait, S: Selector<State, Result = Result>, Result>(
    &'life0 self,
    selector: S
) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>> where
    S: Selector<State, Result = Result> + Send + 'static,
    Result: Send + 'static,
    S: 'async_trait,
    Result: 'async_trait,
    'life0: 'async_trait,
    Self: '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,
    'life0: 'async_trait,
    Self: '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: Subscriber<State> + Send + 'static>(
    &'life0 self,
    subscriber: S
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    S: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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