Struct Store 

pub struct Store<State, Service, Action> {
    reducer: Reducer<State, Action>,
    effects: Effects<State, Service, Action>,
    pub state: StateWrapper<State>,
    pub service: Service,
    initial_monotonic_time: Instant,
    initial_time: Timestamp,
    recursion_depth: u32,
    last_action_id: ActionId,
}

Main struct for the state machine.

Exposes a Store::dispatch method, using which actions can be dispatched, which triggers a

1. Reducer - to update the state.
2. Effects - to trigger side-effects of the action.

Fields

reducer: Reducer<State, Action>

effects: Effects<State, Service, Action>

state: StateWrapper<State>

Current State.

Immutable access can be gained using store.state.get(). Mutation can only happen inside reducer.

service: Service

initial_monotonic_time: Instant

initial_time: Timestamp

recursion_depth: u32

Current recursion depth of dispatch.

last_action_id: ActionId

Implementations

impl<State, Service, Action> Store<State, Service, Action>

where Service: TimeService, Action: EnablingCondition<State>,

pub fn new( reducer: Reducer<State, Action>, effects: Effects<State, Service, Action>, service: Service, initial_time: SystemTime, initial_state: State, ) -> Self

Creates a new store.

pub fn state(&self) -> &State

Returns the current state.

pub fn service(&mut self) -> &mut Service

pub fn monotonic_to_time(&self, monotonic_time: Instant) -> u64

Convert monotonic time to system clock in nanoseconds from epoch.

pub fn dispatch<T>(&mut self, action: T) -> bool

where T: Into<Action> + EnablingCondition<State>,

Dispatch an Action.

Returns true if the action was enabled, hence if it was dispatched to reducer and then effects.

If action is not enabled, we return false and do nothing.

pub fn dispatch_callback<T>(&mut self, callback: Callback<T>, args: T) -> bool

where T: 'static, Action: From<AnyAction> + EnablingCondition<State>,

pub fn sub_dispatch<A, S>(&mut self, action: A) -> bool

where A: Into<<Self as SubStore<State, S>>::SubAction> + EnablingCondition<S>, <Self as SubStore<State, S>>::SubAction: Into<Action>, Self: SubStore<State, S>,

Dispatch an Action (For SubStore).

Returns true if the action was enabled, hence if it was dispatched to reducer and then effects.

If action is not enabled, we return false and do nothing.

fn update_action_id(&mut self) -> ActionId

fn dispatch_enabled(&mut self, action: Action)

Dispatches action without checking the enabling condition.

fn dispatch_reducer( &mut self, action_with_id: &ActionWithMeta<Action>, dispatcher: &mut Dispatcher<Action, State>, )

Runs the reducer.

fn dispatch_effects( &mut self, action_with_id: ActionWithMeta<Action>, queued: Dispatcher<Action, State>, )

Runs the effects.

Trait Implementations

impl<State, Service, Action> Clone for Store<State, Service, Action>

where State: Clone, Service: Clone, Action: Clone + EnablingCondition<State>,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.