Struct reactive_state::StoreRef

pub struct StoreRef<State, Action, Event, Effect>(_);

A wrapper for an Rc reference to a Store.

This wrapper exists to provide a standard interface for re-useable middleware and other components which may require a long living reference to the store in order to dispatch actions or modify it in some manner that could not be handled by a simple &Store.

Implementations

impl<State, Action, Event, Effect> StoreRef<State, Action, Event, Effect> where
    Event: StoreEvent + Clone + Hash + Eq, 

pub fn new<R: Reducer<State, Action, Event, Effect> + 'static>(
    reducer: R,
    initial_state: State
) -> Self

Methods from Deref<Target = Store<State, Action, Event, Effect>>

pub fn state(&self) -> Rc<State>

Get the current State stored in this store.

Modifications to this state need to be performed by dispatching an Action to the store using dispatch().

pub fn dispatch<A: Into<Action>>(&self, action: A)

Dispatch an Action to be passed to the Reducer in order to modify the State in this store, and produce Events to be sent to the store listeners.

pub fn subscribe<L: AsListener<State, Event>>(&self, listener: L)

Subscribe a Listener to changes in the store state and events produced by the Reducer as a result of Actions dispatched via dispatch().

The listener is a weak reference; when the strong reference associated with it (usually Callback) is dropped, the listener will be removed from this store upon dispatch().

If you want to subscribe to state changes associated with specific Events, see subscribe_event() or subscribe_event()

pub fn subscribe_event<L: AsListener<State, Event>>(
    &self,
    listener: L,
    event: Event
)

Subscribe a Listener to changes in the store state and events produced by the Reducer as a result of Actions being dispatched via dispatch() and reduced with the store's Reducer. This subscription is only active changes which produce the specific matching event from the Reducer.

The listener is a weak reference; when the strong reference associated with it (usually Callback) is dropped, the listener will be removed from this store upon dispatch().

pub fn subscribe_events<L: AsListener<State, Event>, E: IntoIterator<Item = Event>>(
    &self,
    listener: L,
    events: E
)

Subscribe a Listener to changes in the store state and events produced by the Reducer as a result of Actions being dispatched via dispatch() and reduced with the store's Reducer. This subscription is only active changes which produce any of the specific matching events from the Reducer.

The listener is a weak reference; when the strong reference associated with it (usually Callback) is dropped, the listener will be removed from this store upon dispatch().

pub fn add_middleware<M: Middleware<State, Action, Event, Effect> + 'static>(
    &self,
    middleware: M
)

Add Middleware to modify the behaviour of this Store during a dispatch().

Trait Implementations

impl<State, Action, Event, Effect> Clone for StoreRef<State, Action, Event, Effect>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<State, Action, Event, Effect> Deref for StoreRef<State, Action, Event, Effect>

type Target = Store<State, Action, Event, Effect>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<State, Action, Event, Effect> PartialEq<StoreRef<State, Action, Event, Effect>> for StoreRef<State, Action, Event, Effect>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.