doWhile method

Future doWhile (FutureOr<bool> action())

Performs an operation repeatedly until it returns false.

The operation, action, may be either synchronous or asynchronous.

The operation is called repeatedly as long as it returns either the bool value true or a Future<bool> which completes with the value true.

If a call to action returns false or a Future that completes to false, iteration ends and the future returned by doWhile is completed with a null value.

If a call to action throws or a future returned by action completes with an error, iteration ends and the future returned by doWhile completes with the same error.

Calls to action may happen at any time, including immediately after calling doWhile. The only restriction is a new call to action won't happen before the previous call has returned, and if it returned a Future<bool>, not until that future has completed.

Implementation

static Future doWhile(FutureOr<bool> action()) {
  _Future doneSignal = new _Future();
  void Function(bool) nextIteration;
  // Bind this callback explicitly so that each iteration isn't bound in the
  // context of all the previous iterations' callbacks.
  // This avoids, e.g., deeply nested stack traces from the stack trace
  // package.
  nextIteration = Zone.current.bindUnaryCallbackGuarded((bool keepGoing) {
    while (keepGoing) {
      FutureOr<bool> result;
      try {
        result = action();
      } catch (error, stackTrace) {
        // Cannot use _completeWithErrorCallback because it completes
        // the future synchronously.
        _asyncCompleteWithErrorCallback(doneSignal, error, stackTrace);
        return;
      }
      if (result is Future<bool>) {
        result.then(nextIteration, onError: doneSignal._completeError);
        return;
      }
      keepGoing = result;
    }
    doneSignal._complete(null);
  });
  nextIteration(true);
  return doneSignal;
}