description

# asyncMap<E> method Null safety

Stream<E> asyncMap <E>(

1. FutureOr<E> convert(
   1. T event
   )

)

Creates a new stream with each data event of this stream asynchronously mapped to a new event.

This acts like map, except that `convert` may return a Future, and in that case, this stream waits for that future to complete before continuing with its result.

The returned stream is a broadcast stream if this stream is.

## Implementation

    Stream<E> asyncMap<E>(FutureOr<E> convert(T event)) {
      _StreamControllerBase<E> controller;
      if (isBroadcast) {
        controller = _SyncBroadcastStreamController<E>(null, null);
      } else {
        controller = _SyncStreamController<E>(null, null, null, null);
      }

      controller.onListen = () {
        StreamSubscription<T> subscription = this.listen(null,
            onError: controller._addError, // Avoid Zone error replacement.
            onDone: controller.close);
        FutureOr<Null> add(E value) {
          controller.add(value);
        }

        final addError = controller._addError;
        final resume = subscription.resume;
        subscription.onData((T event) {
          FutureOr<E> newValue;
          try {
            newValue = convert(event);
          } catch (e, s) {
            controller.addError(e, s);
            return;
          }
          if (newValue is Future<E>) {
            subscription.pause();
            newValue.then(add, onError: addError).whenComplete(resume);
          } else {
            // TODO(40014): Remove cast when type promotion works.
            controller.add(newValue as dynamic);
          }
        });
        controller.onCancel = subscription.cancel;
        if (!isBroadcast) {
          controller
            ..onPause = subscription.pause
            ..onResume = resume;
        }
      };
      return controller.stream;
    }