Store<S> class abstract

A redux like store that manages state.

Contrary to the original design the store doesn't use configured actions, but instead uses a synchronous update callback. Furthermore, various extensions are provided to asynchronously let an Observable or Future manipulate the state.

Middleware is provided by providing other implementations of the Store interface, and possibly wrapping and delegating to the DefaultStore.

The canonical example with the counter looks like this:

// Create a store with the initial value 0. final store = Store

// Subscribe to state changes and print the new state to the console. store.subscribe(Observer.next((state) => print(state)));

// Increment the value by one. In a more complicated example one // could extract the function to be standalone, or generalize it to // handle different actions. store.update((state) => state + 1);

// Alternatively, one can subscribe to an observable and provide // reducer functions for its events to update the state asynchronously. // The following lines set the state to a random value every 10 seconds. final randomValue = timer(period: Duration(seconds: 10)) .map((_) => Random().nextInt(100)); store.addObservable(randomValue, next: (state, value) => value);

Implemented types
Implementers
Available extensions

Constructors

Store(S initialState)
Constructs a standard store from an initial state.
factory

Properties

hashCode → int
The hash code for this object.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
state → S
Returns the current state.
no setter

Methods

addFuture<T>(Future<T> future, {S onValue(S state, T value)?, S onError(S state, Object error, StackTrace stackTrace)?}) → Future<S>

Available on Store<S>, provided by the FutureStoreExtension extension

Adds an future that asynchronously contributes to the state through onValue and onError reducers. These functions receive the current state and resolution of the Future to produce a new state.
addObservable<T>(Observable<T> observable, {S next(S state, T value)?, S error(S state, Object error, StackTrace stackTrace)?, S complete(S state)?, bool ignoreErrors = false}) → Disposable

Available on Store<S>, provided by the ObservableStoreExtension extension

Adds an observable that asynchronously contributes to the state through next, error and complete reducers. These functions receive the current state and the events of the Observer to produce a new state.
addStream<T>(Stream<T> stream, {S onData(S state, T event)?, S onError(S state, Object error, StackTrace stackTrace)?, S onDone(S state)?, bool? cancelOnError}) → StreamSubscription<T>

Available on Store<S>, provided by the StreamStoreExtension extension

Adds a stream that asynchronously contributes to the state through onData, onError and onDone reducers. These functions receive the current state and the events of the Stream to produce a new state.
audit<R>(DurationSelector<T, R> durationSelector) → Observable<T>

Available on Observable<T>, provided by the AuditOperator extension

Ignores values from this Observable for a duration determined by the Observable returned from durationSelector, then emits the most recent source value, then repeats the process.
auditTime(Duration duration, {Scheduler? scheduler}) → Observable<T>

Available on Observable<T>, provided by the AuditOperator extension

Ignores values from this Observable for the given duration, then emits the most recent source value, then repeats the process.
beginWith(Observable<T> observable) → Observable<T>

Available on Observable<T>, provided by the ConcatOperator extension

Prepends the emission of items with an Observable.
buffer<R>({Scheduler? scheduler, Observable<R>? trigger, int? maxLength, Duration? maxAge}) → Observable<List<T>>

Available on Observable<T>, provided by the BufferOperator extension

Gathers the items emitted by this Observable and bundles these items into a list until either
cast<R>() → Observable<R>

Available on Observable<T>, provided by the CastOperator extension

Casts the values from this Observable to R.
catchError<E>(ErrorHandler<T, E> handler) → Observable<T>

Available on Observable<T>, provided by the CatchErrorOperator extension

Catches errors of type E thrown by this Observable and handles them by either returning a new Observable of type T, throwing the same or a different error, or returning null to complete the Observable.
combineLatest() → Observable<List<T>>

Available on Observable<Observable<T>>, provided by the CombineLatestOperator extension

Combines multiple source to create an Observable whose values are calculated from the latest values of each of its inputs.
compose<R>(Transformer<T, R> transformation) → Observable<R>

Available on Observable<T>, provided by the ComposeOperator extension

Prepends the emission of items with transformation.
count() → Observable<int>

Available on Observable<T>, provided by the CountOperator extension

Counts the number of emissions of this Observable and emits that number on completion.
debounce<R>(DurationSelector<T, R> durationSelector) → Observable<T>

Available on Observable<T>, provided by the DebounceOperator extension

Emits a value from this Observable only after a particular time span determined by another Observable has passed without another emission.
debounceTime(Duration duration, {Scheduler? scheduler}) → Observable<T>

Available on Observable<T>, provided by the DebounceOperator extension

Emits a value from this Observable only after a particular time span has passed without another emission.
defaultIfEmpty(T value) → Observable<T>

Available on Observable<T>, provided by the DefaultIfEmptyOperator extension

Emits a given value if this Observable completes without emitting any value, otherwise mirrors the source.
delay<R>(DurationSelector<T, R> durationSelector) → Observable<T>

Available on Observable<T>, provided by the DelayOperator extension

Delays the emission of items from this Observable until the Observable returned from durationSelector triggers.
delayTime(Duration duration, {Scheduler? scheduler}) → Observable<T>

Available on Observable<T>, provided by the DelayOperator extension

Delays the emission of items from this Observable by a given timeout.
dematerialize() → Observable<T>

Available on Observable<Event<T>>, provided by the DematerializeOperator extension

Dematerialize events of this Observable into from a sequence of Event objects.
distinct({Predicate2<T, T>? equals, Map1<T, int>? hashCode}) → Observable<T>

Available on Observable<T>, provided by the DistinctOperator extension

Emits all items emitted by this Observable that are distinct from the previous ones.
distinctUntilChanged<K>({Map1<T, K>? key, Predicate2<K, K>? compare}) → Observable<T>

Available on Observable<T>, provided by the DistinctUntilChangedOperator extension

Emits all items emitted by this Observable that are different from the previous one.
endWith(Observable<T> observable) → Observable<T>

Available on Observable<T>, provided by the ConcatOperator extension

Appends the emission of items with an Observable.
exhaustAll({int concurrent = 1}) → Observable<T>

Available on Observable<Observable<T>>, provided by the ExhaustAllOperator extension

Emits and completes higher-order Observable. Subscribes to at most concurrent sources, and drops observables exceeding this threshold.
exhaustMap<R>(Map1<T, Observable<R>> project, {int concurrent = 1}) → Observable<R>

Available on Observable<T>, provided by the ExhaustMapOperator extension

Emits and completes values from a higher-order Observable retrieved by projecting the values of the source to higher-order Observables. Subscribes to at most concurrent sources, drops observables exceeding this threshold.
exhaustMapTo<R>(Observable<R> observable, {int concurrent = 1}) → Observable<R>

Available on Observable<T>, provided by the ExhaustMapOperator extension

Emits and completes values from single higher-order Observable. Subscribes to at most concurrent sources, drops observables exceeding this threshold.
finalize(CompleteCallback finalize) → Observable<T>

Available on Observable<T>, provided by the FinalizeOperator extension

Return an Observable that mirrors this Observable, but will call a specified function when the source terminates on completion or error.
findFirst(Predicate1<T> predicate) → Observable<T>

Available on Observable<T>, provided by the FirstOperator extension

Emits the first item of this Observable sequence matching the predicate, or emits an TooFewError otherwise.
findFirstOrDefault(Predicate1<T> predicate, T value) → Observable<T>

Available on Observable<T>, provided by the FirstOperator extension

Emits the first item of this Observable sequence matching the predicate, or the provided default value otherwise.
findFirstOrElse(Predicate1<T> predicate, Map0<T> callback) → Observable<T>

Available on Observable<T>, provided by the FirstOperator extension

Emits the first item of this Observable sequence matching the predicate, or evaluate the provided callback otherwise.
findLast(Predicate1<T> predicate) → Observable<T>

Available on Observable<T>, provided by the LastOperator extension

Emits the last item of this Observable matching the predicate, or emits an TooFewError otherwise.
findLastOrDefault(Predicate1<T> predicate, T value) → Observable<T>

Available on Observable<T>, provided by the LastOperator extension

Emits the last item of this Observable matching the predicate, or the provided default value otherwise.
findLastOrElse(Predicate1<T> predicate, Map0<T> callback) → Observable<T>

Available on Observable<T>, provided by the LastOperator extension

Emits the last item of this Observable matching the predicate, or evaluate the provided callback otherwise.
first() → Observable<T>

Available on Observable<T>, provided by the FirstOperator extension

Emits the first item of this Observable, or emits an TooFewError otherwise.
firstOrDefault(T value) → Observable<T>

Available on Observable<T>, provided by the FirstOperator extension

Emits the first item of this Observable, or the provided default value otherwise.
firstOrElse(Map0<T> callback) → Observable<T>

Available on Observable<T>, provided by the FirstOperator extension

Emits the first item of this Observable, or evaluate the provided callback otherwise.
flatMap<R>(Map1<T, Observable<R>> project, {int concurrent = maxInteger}) → Observable<R>

Available on Observable<T>, provided by the FlatMapOperator extension

For each value of this Observable, transform that value to a higher-order observable with the provided project function and merge its emitted values. Subscribe to at most concurrent sources.
flatMapTo<R>(Observable<R> observable, {int concurrent = maxInteger}) → Observable<R>

Available on Observable<T>, provided by the FlatMapOperator extension

For each value of this Observable, merge all values from the single higher-order observable. Subscribe to at most concurrent sources.
flatten({int concurrent = maxInteger}) → Observable<T>

Available on Observable<Observable<T>>, provided by the FlattenObservable extension

For each observable of this Observable, subscribe to at most concurrent observables and emit all values.
fold<R>(R initialValue, Map2<R, T, R> transform) → Observable<R>

Available on Observable<T>, provided by the FoldOperator extension

Combines a sequence of values by repeatedly applying transform, starting with the provided initialValue.
ignoreElements() → Observable<T>

Available on Observable<T>, provided by the IgnoreElementsOperator extension

Ignores all items emitted by this Observable and only passes errors and completion events.
isEmpty() → Observable<bool>

Available on Observable<T>, provided by the IsEmptyOperator extension

Emits true if this Observable completes without emitting any values, otherwise emits false.
last() → Observable<T>

Available on Observable<T>, provided by the LastOperator extension

Emits the last item of this Observable, or emits an TooFewError otherwise.
lastOrDefault(T value) → Observable<T>

Available on Observable<T>, provided by the LastOperator extension

Emits the last item of this Observable, or the provided default value otherwise.
lastOrElse(Map0<T> callback) → Observable<T>

Available on Observable<T>, provided by the LastOperator extension

Emits the last item of this Observable, or evaluate the provided callback otherwise.
map<R>(Map1<T, R> transform) → Observable<R>

Available on Observable<T>, provided by the MapOperator extension

Applies the given projection function transform to each value emitted by this Observable, and emits the resulting value.
mapTo<R>(R value) → Observable<R>

Available on Observable<T>, provided by the MapOperator extension

Emits a constant value for each value emitted by this Observable.
materialize() → Observable<Event<T>>

Available on Observable<T>, provided by the MaterializeOperator extension

Materializes the events of this Observable as Event objects.
mergeAll({int concurrent = maxInteger}) → Observable<T>

Available on Observable<Observable<T>>, provided by the MergeAllOperator extension

For each observable of this Observable, subscribe to at most concurrent observables and emit all values.
mergeMap<R>(Map1<T, Observable<R>> project, {int concurrent = maxInteger}) → Observable<R>

Available on Observable<T>, provided by the MergeMapOperator extension

For each value of this Observable, transform that value to a higher-order observable with the provided project function and merge its emitted values. Subscribe to at most concurrent sources.
mergeMapTo<R>(Observable<R> observable, {int concurrent = maxInteger}) → Observable<R>

Available on Observable<T>, provided by the MergeMapOperator extension

For each value of this Observable, merge all values from the single higher-order observable. Subscribe to at most concurrent sources.
multicast({Subject<T>? subject, Map0<Subject<T>>? factory}) → ConnectableObservable<T>

Available on Observable<T>, provided by the MulticastOperator extension

Returns an multicast observable that shares the underlying stream.
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
observeOn(Scheduler scheduler, {Duration? delay}) → Observable<T>

Available on Observable<T>, provided by the ObserveOnOperator extension

Re-emits all notifications from this Observable with a custom scheduler.
pairwise() → Observable<(T, T)>

Available on Observable<T>, provided by the PairwiseOperator extension

Groups the items emitted by an Observable into a record type that represent the latest pair of items emitted by the source Observable.
publishBehavior(T value) → ConnectableObservable<T>

Available on Observable<T>, provided by the PublishOperator extension

Creates a ConnectableObservable that emits its initial or last seen value to its subscribers.
publishLast() → ConnectableObservable<T>

Available on Observable<T>, provided by the PublishOperator extension

Creates a ConnectableObservable that emits its last value to all its subscribers on completion.
publishReplay({int? bufferSize}) → ConnectableObservable<T>

Available on Observable<T>, provided by the PublishOperator extension

Creates a ConnectableObservable that replays all its previous values to new subscribers.
reduce(Map2<T, T, T> transform) → Observable<T>

Available on Observable<T>, provided by the ReduceOperator extension

Combines a sequence of values by repeatedly applying transform.
repeat([int count = maxInteger]) → Observable<T>

Available on Observable<T>, provided by the RepeatOperator extension

Resubscribes on this observable count times.
sample<R>(Observable<R> trigger) → Observable<T>

Available on Observable<T>, provided by the SampleOperator extension

Emits the most recently emitted value from this Observable whenever the trigger emits.
sampleTime(Duration duration, {Scheduler? scheduler}) → Observable<T>

Available on Observable<T>, provided by the SampleOperator extension

Emits the most recently emitted value from this Observable within periodic time intervals.
single() → Observable<T>

Available on Observable<T>, provided by the SingleOperator extension

Emits the single element of this Observable, or emits TooFewError if there was no element, or emits TooManyError if there was more than 1 element.
singleOrDefault({required T tooFew, required T tooMany}) → Observable<T>

Available on Observable<T>, provided by the SingleOperator extension

Emits the single element of this Observable, or emits tooFew if there was no element, or emits tooMany if there was more than 1 element.
singleOrElse({required Map0<T> tooFew, required Map0<T> tooMany}) → Observable<T>

Available on Observable<T>, provided by the SingleOperator extension

Emits the single element of this Observable, or evaluates the tooFew callback if there was no element, or evaluates the tooMany callback if there was more than 1 element.
skip([int count = 1]) → Observable<T>

Available on Observable<T>, provided by the SkipOperator extension

Skips over the first count values before starting to emit.
skipUntil<R>(Observable<R> trigger) → Observable<T>

Available on Observable<T>, provided by the SkipUntilOperator extension

Skips over all values until an Observable emits a first value.
skipWhile(Predicate1<T> predicate) → Observable<T>

Available on Observable<T>, provided by the SkipWhileOperator extension

Skips over the values while the predicate is true.
subscribe(Observer<S> observer) → Disposable
Subscribes with the provided observer.
inherited
switchAll() → Observable<T>

Available on Observable<Observable<T>>, provided by the SwitchAllOperator extension

Emits values only from the most recently received higher-order Observable.
switchMap<R>(Map1<T, Observable<R>> project) → Observable<R>

Available on Observable<T>, provided by the SwitchMapOperator extension

Emits values from the most recent higher-order Observable retrieved by projecting the values of the source to higher-order Observables.
switchMapTo<R>(Observable<R> observable) → Observable<R>

Available on Observable<T>, provided by the SwitchMapOperator extension

Emits all values from the most recent higher-order observable.
take([int count = 1]) → Observable<T>

Available on Observable<T>, provided by the TakeOperator extension

Emits the first count values before completing.
takeLast([int count = 1]) → Observable<T>

Available on Observable<T>, provided by the TakeLastOperator extension

Emits the last count values emitted by the source.
takeUntil<R>(Observable<R> trigger) → Observable<T>

Available on Observable<T>, provided by the TakeUntilOperator extension

Emits values until an Observable emits a first value.
takeWhile(Predicate1<T> predicate, {bool inclusive = false}) → Observable<T>

Available on Observable<T>, provided by the TakeWhileOperator extension

Emits values while the predicate returns true.
tap(Observer<T> handler) → Observable<T>

Available on Observable<T>, provided by the TapOperator extension

Perform a side effect for every emission on the source.
throttle<R>(DurationSelector<T, R> durationSelector, {bool leading = true, bool trailing = true}) → Observable<T>

Available on Observable<T>, provided by the ThrottleOperator extension

Emits a value from this Observable, then ignores values for the duration until the Observable returned by durationSelector triggers a value or completes.
throttleTime(Duration duration, {bool leading = true, bool trailing = true, Scheduler? scheduler}) → Observable<T>

Available on Observable<T>, provided by the ThrottleOperator extension

Emits a value from this Observable, then ignores values for duration.
timeout({Duration? first, Duration? between, Duration? total, Scheduler? scheduler}) → Observable<T>

Available on Observable<T>, provided by the TimeoutOperator extension

totals with a TimeoutError, if the observable fails to emit a value in the given time span.
toFuture() → Future<T>

Available on Observable<T>, provided by the ObservableToFuture extension

Returns a Future that completes with the first value of this Observable.
toList([Map0<List<T>>? constructor]) → Observable<List<T>>

Available on Observable<T>, provided by the ToListOperator extension

Returns a List from an observable sequence.
toListMultimap<K, V>({Map0<ListMultimap<K, V>>? constructor, Map1<T, K>? keySelector, Map1<T, V>? valueSelector}) → Observable<ListMultimap<K, V>>

Available on Observable<T>, provided by the ToMapOperator extension

Returns a ListMultimap from an observable sequence.
toMap<K, V>({Map0<Map<K, V>>? constructor, Map1<T, K>? keySelector, Map1<T, V>? valueSelector}) → Observable<Map<K, V>>

Available on Observable<T>, provided by the ToMapOperator extension

Returns a Map from an observable sequence.
toSet([Map0<Set<T>>? constructor]) → Observable<Set<T>>

Available on Observable<T>, provided by the ToSetOperator extension

Returns a Set from an observable sequence.
toSetMultimap<K, V>({Map0<SetMultimap<K, V>>? constructor, Map1<T, K>? keySelector, Map1<T, V>? valueSelector}) → Observable<SetMultimap<K, V>>

Available on Observable<T>, provided by the ToMapOperator extension

Returns a SetMultimap from an observable sequence.
toStream() → Stream<T>

Available on Observable<T>, provided by the ObservableToStream extension

Returns a Stream that subscribes to and emits the values of this Observable.
toString() → String
A string representation of this object.
inherited
update(Updater<S> updater) → S
Updates the current state.
where(Predicate1<T> predicate) → Observable<T>

Available on Observable<T>, provided by the WhereOperator extension

Filter items emitted by the source Observable by only emitting those that satisfy a specified predicate.
whereType<R>() → Observable<R>

Available on Observable<T>, provided by the WhereTypeOperator extension

Filter items emitted by the source Observable by only emitting those that are of the specified type.

Operators

operator ==(Object other) → bool
The equality operator.
inherited