description

# asyncMap<E> method

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, in that `convert` function is called once per data event, but here `convert` may be asynchronous and return a Future. If that happens, this stream waits for that future to complete before continuing with further events.

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) {
            var error = _interceptCaughtError(e, s);
            controller.addError(error.error, error.stackTrace);
            return;
          }
          if (newValue is Future<E>) {
            subscription.pause();
            newValue.then(add, onError: addError).whenComplete(resume);
          } else {
            controller.add(newValue);
          }
        });
        controller.onCancel = subscription.cancel;
        if (!isBroadcast) {
          controller
            ..onPause = subscription.pause
            ..onResume = resume;
        }
      };
      return controller.stream;
    }