StreamQueue
starts listening immediately to broadcast strings.DelegatingStream.typed
. Use Stream.cast
instead.DelegatingStreamSubcription.typed
and DelegatingStreamConsumer.typed
. For each of these the Stream
should be cast to the correct type before being used.DelegatingStreamSink.typed
. DelegatingSink.typed
, DelegatingEventSink.typed
, DelegatingStreamConsumer.typed
. For each of these a new StreamController
can be constructed to forward to the sink. StreamController<T>()..stream.cast<S>().pipe(sink)
typedStreamTransformer
. Cast after transforming instead.StreamSinkTransformer.typed
since there was no usage.CancelablOperation.fromFuture
, indicate that isCompleted
starts true
.StreamGroup.mergeBroadcast()
utility.RestartableTimer.tick
.then
to CancelableOperation
.CancelableOperation.valueOrCancellation
's type signatureisCanceled
and isCompleted
to CancelableOperation
.<3.0.0
.DelegatingFuture.typed
, it is not necessary in Dart 2.Stream
.StreamQueue
.Add support for Dart 2.0 library changes to Stream
and StreamTransformer
. Changed classes that implement StreamTransformer
to extend StreamTransformerBase
, and changed signatures of firstWhere
, lastWhere
, and singleWhere
on classes extending Stream
. See also issue 31847.
StreamQueue.startTransaction()
and related methods when rejecting a transaction that isn't the oldest request in the queue.Timer
.Remove deprecated public result.dart
and stream_zip.dart
libraries and deprecated classes ReleaseStreamTransformer
and CaptureStreamTransformer
.
Add captureAll
and flattenList
static methods to Result
.
Change ErrorResult
to not be generic and always be a Result<Null>
. That makes an error independent of the type of result it occurs instead of.
TypeSafeStream
extend Stream
instead of implementing it. This ensures that new methods on Stream
are automatically picked up, they will go through the listen
method which type-checks every event.FutureOr
for various APIs that had previously used dynamic
.Add collectBytes
and collectBytesCancelable
functions which collects list-of-byte events into a single byte list.
Fix a bug where rejecting a StreamQueueTransaction
would throw a StateError
if StreamQueue.rest
had been called on one of its child queues.
StreamQueue.withTransaction()
now properly returns whether or not the transaction was committed.
Add an AsyncCache
class that caches asynchronous operations for a period of time.
Add StreamQueue.peek
and StreamQueue.lookAheead
. These allow users to look at events without consuming them.
Add StreamQueue.startTransaction()
and StreamQueue.withTransaction()
. These allow users to conditionally consume events based on their values.
Add StreamQueue.cancelable()
, which allows users to easily make a CancelableOperation
that can be canceled without affecting the queue.
Add StreamQueue.eventsDispatched
which counts the number of events that have been dispatched by a given queue.
Add a subscriptionTransformer()
function to create StreamTransformer
s that modify the behavior of subscriptions to a stream.
Add a typedStreamTransformer()
function. This wraps an untyped StreamTransformer
with the correct type parameters, and asserts the types of events as they're emitted from the transformed stream.
Add a StreamSinkTransformer.typed()
static method. This wraps an untyped StreamSinkTransformer
with the correct type parameters, and asserts the types of arguments passed in to the resulting sink.
Add DelegatingFuture.typed()
, DelegatingStreamSubscription.typed()
, DelegatingStreamConsumer.typed()
, DelegatingSink.typed()
, DelegatingEventSink.typed()
, and DelegatingStreamSink.typed()
static methods. These wrap untyped instances of these classes with the correct type parameter, and assert the types of values as they're accessed.
Add a DelegatingStream
class. This is behaviorally identical to StreamView
from dart:async
, but it follows this package's naming conventions and provides a DelegatingStream.typed()
static method.
Fix all strong mode warnings and add generic method annotations.
new StreamQueue()
, new SubscriptionStream()
, new DelegatingStreamSubscription()
, new DelegatingStreamConsumer()
, new DelegatingSink()
, new DelegatingEventSink()
, and new DelegatingStreamSink()
now take arguments with generic type arguments (for example Stream<T>
) rather than without (for example Stream<dynamic>
). Passing a type that wasn't is
-compatible with the fully-specified generic would already throw an error under some circumstances, so this is not considered a breaking change.
ErrorResult
now takes a type parameter.
Result.asError
now returns a Result<T>
.
Deprecate top-level libraries other than package:async/async.dart
, which exports these libraries' interfaces.
Add Result.captureStreamTransformer
, Result.releaseStreamTransformer
, Result.captureSinkTransformer
, and Result.releaseSinkTransformer
.
Deprecate CaptureStreamTransformer
, ReleaseStreamTransformer
, CaptureSink
, and ReleaseSink
. Result.captureStreamTransformer
, Result.releaseStreamTransformer
, Result.captureSinkTransformer
, and Result.releaseSinkTransformer
should be used instead.
Added StreamSinkCompleter
, for creating a StreamSink
now and providing its destination later as another sink.
Added StreamCompleter.setError
, a shortcut for emitting a single error event on the resulting stream.
Added NullStreamSink
, an implementation of StreamSink
that discards all events.
SingleSubscriptionTransformer
, a StreamTransformer
that converts a broadcast stream into a single-subscription stream.Added CancelableOperation.valueOrCancellation()
, which allows users to be notified when an operation is canceled elsewhere.
Added StreamSinkTransformer
which transforms events before they‘re passed to a StreamSink
, similarly to how StreamTransformer
transforms events after they’re emitted by a stream.
LazyStream
, which forwards to the return value of a callback that's only called when the stream is listened to.Added AsyncMemoizer.future
, which allows the result to be accessed before runOnce()
is called.
Added CancelableOperation
, an asynchronous operation that can be canceled. It can be created using a CancelableCompleter
.
Added RestartableTimer
, a non-periodic timer that can be reset over and over.
Added StreamCompleter
class for creating a stream now and providing its events later as another stream.
Added StreamQueue
class which allows requesting events from a stream before they are avilable. It is like a StreamIterator
that can queue requests.
Added SubscriptionStream
which creates a single-subscription stream from an existing stream subscription.
Added a ResultFuture
class for synchronously accessing the result of a wrapped future.
Added FutureGroup.onIdle
and FutureGroup.isIdle
, which provide visibility into whether a group is actively waiting on any futures.
Add an AsyncMemoizer
class for running an asynchronous block of code exactly once.
Added delegating wrapper classes for a number of core async types: DelegatingFuture
, DelegatingStreamConsumer
, DelegatingStreamController
, DelegatingSink
, DelegatingEventSink
, DelegatingStreamSink
, and DelegatingStreamSubscription
. These are all simple wrappers that forward all calls to the wrapped objects. They can be used to expose only the desired interface for subclasses, or extended to add extra functionality.
Added a FutureGroup
class for waiting for a group of futures, potentially of unknown size, to complete.
Added a StreamGroup
class for merging the events of a group of streams, potentially of unknown size.
Added a StreamSplitter
class for splitting a stream into multiple new streams.