Buffers a number of values from the source Stream by count then
emits the buffer and clears it, and starts a new buffer each
startBufferEvery values. If startBufferEvery is not provided,
then new buffers are started immediately at the start of the source
and when each buffer closes and is emitted.
Acts as a container for multiple subscriptions that can be canceled at once
e.g. view subscriptions in Flutter that need to be canceled on view disposal
A ConnectableStream resembles an ordinary Stream, except that it
can be listened to multiple times and does not begin emitting items when
it is listened to, but only when its connect method is called.
Transforms a Stream so that will only emit items from the source sequence
if a window has completed, without the source sequence emitting
another item.
The Delay operator modifies its source Stream by pausing for
a particular increment of time (that you specify) before emitting
each of the source Stream’s items.
This has the effect of shifting the entire sequence of items emitted
by the Stream forward in time by that specified increment.
Invokes the given callback at the corresponding point the the stream
lifecycle. For example, if you pass in an onDone callback, it will
be invoked when the stream finishes emitting items.
Converts events from the source stream into a new Stream using a given
mapper. It ignores all items from the source stream until the new stream
completes.
Converts each emitted item into a new Stream using the given mapper function,
while limiting the maximum number of concurrent subscriptions to these Streams.
The newly created Stream will be listened to and begin emitting items downstream.
This operator is best used when you have a group of streams
and only care about the final emitted value of each.
One common use case for this is if you wish to issue multiple
requests on page load (or some other event)
and only want to take action when a response has been received for all.
The GroupBy operator divides a Stream that emits items into
a Stream that emits GroupedStream,
each one of which emits some subset of the items
from the original source Stream.
A class that encapsulates the Kind of event, value of the event in case of
onData, or the Error in the case of onError.
A container object that wraps the Kind of event (OnData, OnDone, OnError),
and the item or error that was emitted. In the case of onDone, no data is
emitted as part of the Notification.
A ConnectableStream that converts a single-subscription Stream into
a broadcast Stream that replays emitted items to any new listener, and
provides synchronous access to the list of emitted values.
A special StreamController that captures all of the items that have been
added to the controller, and emits those as the first items to any new
listener.
Creates a Stream that will recreate and re-listen to the source
Stream when the notifier emits a new value. If the source Stream
emits an error or it completes, the Stream terminates.
A StreamTransformer that, when the specified window Stream emits
an item or completes, emits the most recently emitted item (if any)
emitted by the source Stream since the previous emission from
the sample Stream.
Convert a Stream that emits Streams (aka a 'Higher Order Stream') into a
single Stream that emits the items emitted by the most-recently-emitted of
those Streams.
Converts each emitted item into a new Stream using the given mapper
function. The newly created Stream will be be listened to and begin
emitting items, and any previously created Stream will stop emitting.
Emits values emitted by the source Stream so long as each value
satisfies the given test. When the test is not satisfied by a value, it
will emit this value as a final event and then complete.
A StreamTransformer that emits a value from the source Stream,
then ignores subsequent source values while the window Stream is open,
then repeats this process.
When listener listens to it, creates a resource object from resource factory function,
and creates a Stream from the given factory function and resource as argument.
Finally when the stream finishes emitting items or stream subscription
is cancelled (call StreamSubscription.cancel or Stream.listen(cancelOnError: true)),
call the disposer function on resource object.
A ConnectableStream that converts a single-subscription Stream into
a broadcast Stream that replays the latest value to any new listener, and
provides synchronous access to the latest emitted value.
Buffers a number of values from the source Stream by count then emits the
buffer as a Stream and clears it, and starts a new buffer each
startBufferEvery values. If startBufferEvery is not provided, then new
buffers are started immediately at the start of the source and when each
buffer closes and is emitted.
Merges the specified streams into one stream sequence using the given
zipper Function whenever all of the stream sequences have produced
an element at a corresponding index.
Extends the Stream class with the ability to transform the Stream into
a new Stream. The new Stream emits items and ignores events from the source
Stream until the new Stream completes.
Extends the Stream class with the ability to convert the source Stream
to a Stream containing only the non-null results
of applying the given transform function to each element of this Stream.
Extends the Stream class with the ability to convert the onData, on Done,
and onError events into Notifications that are passed into the
downstream onData listener.
Extends the Stream with the ability to convert one stream into a new Stream
whenever the source emits an item. Every time a new Stream is created, the
previous Stream is discarded.
Extends the Stream class with the ability to wrap each item emitted by the
source Stream in a Timestamped object that includes the emitted item and
the time when the item was emitted.
Extends the Stream class with the ability to convert the source Stream
to a Stream which emits all the non-null elements
of this Stream, in their original emission order.
Used to annotate a function f. Indicates that f always throws an
exception. Any functions that override f, in class inheritance, are also
expected to conform to this contract.
Used to annotate a method, getter, top-level function, or top-level getter
to indicate that the value obtained by invoking it should not be stored in a
field or top-level variable. The annotation can also be applied to a class
to implicitly annotate all of the valid members of the class, or applied to
a library to annotate all of the valid members of the library, including
classes. If a value returned by an element marked as doNotStore is
returned from a function or getter, that function or getter should be
similarly annotated.
Used to annotate an optional parameter, method, getter or top-level getter
or function that is not intended to be accessed in checked-in code, but
might be ephemerally used during development or local testing.
Used to annotate a library, or any declaration that is part of the public
interface of a library (such as top-level members, class members, and
function parameters) to indicate that the annotated API is experimental and
may be removed or changed at any-time without updating the version of the
containing package, despite the fact that it would otherwise be a breaking
change.
Used to annotate an instance or static method m. Indicates that m must
either be abstract or must return a newly allocated object or null. In
addition, every method that either implements or overrides m is implicitly
annotated with this same annotation.
Used to annotate a declaration which should only be used from within the
package in which it is declared, and which should not be exposed from said
package's public API.
Used to annotate a const constructor c. Indicates that any invocation of
the constructor must use the keyword const unless one or more of the
arguments to the constructor is not a compile-time constant.
Used to annotate an instance member (method, getter, setter, operator, or
field) m. Indicates that every invocation of a member that overrides m
must also invoke m. In addition, every method that overrides m is
implicitly annotated with this same annotation.
Used to annotate an instance member (method, getter, setter, operator, or
field) m in a class C or mixin M. Indicates that m should not be
overridden in any classes that extend or mixin C or M.
Used to annotate a class, mixin, extension, function, method, or typedef
declaration C. Indicates that any type arguments declared on C are to
be treated as optional.
Used to annotate an instance member in a class or mixin which is meant to
be visible only within the declaring library, and to other instance members
of the class or mixin, and their subtypes.
Used to annotate a named parameter p in a method or function f.
Indicates that every invocation of f must include an argument
corresponding to p, despite the fact that p would otherwise be an
optional parameter.
Used to annotate a method, field, or getter within a class, mixin, or
extension, or a or top-level getter, variable or function to indicate that
the value obtained by invoking it should be used. A value is considered used
if it is assigned to a variable, passed to a function, or used as the target
of an invocation, or invoked (if the result is itself a function).
Used to annotate an instance member that was made public so that it could be
overridden but that is not intended to be referenced from outside the
defining library.
