description

# singleWhere method Null safety

Future<T> singleWhere (

1. bool test(
   1. T element
   ),
2. {T orElse(
   )}

)

Finds the single element in this stream matching `test`.

Like lastWhere, except that it is an error if more than one matching element occurs in this stream.

## Implementation

    Future<T> singleWhere(bool test(T element), {T orElse()?}) {
      _Future<T> future = new _Future<T>();
      late T result;
      bool foundResult = false;
      StreamSubscription<T> subscription =
          this.listen(null, onError: future._completeError, onDone: () {
        if (foundResult) {
          future._complete(result);
          return;
        }
        if (orElse != null) {
          _runUserCode(orElse, future._complete, future._completeError);
          return;
        }
        try {
          throw IterableElementError.noElement();
        } catch (e, s) {
          _completeWithErrorCallback(future, e, s);
        }
      }, cancelOnError: true);

      subscription.onData((T value) {
        _runUserCode(() => test(value), (bool isMatch) {
          if (isMatch) {
            if (foundResult) {
              try {
                throw IterableElementError.tooMany();
              } catch (e, s) {
                _cancelAndErrorWithReplacement(subscription, future, e, s);
              }
              return;
            }
            foundResult = true;
            result = value;
          }
        }, _cancelAndErrorClosure(subscription, future));
      });
      return future;
    }