Format all dart: library files

sdk/lib/async/future.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.async;
 
 /// A type representing values that are either `Future<T>` or `T`.
 ///
 /// This class declaration is a public stand-in for an internal
 /// future-or-value generic type. References to this class are resolved to the
@@ skipping 277 matching lines @@
    * error to occur, the remaining errors are silently dropped).
    *
    * If [cleanUp] is provided, in the case of an error, any non-null result of
    * a successful future is passed to `cleanUp`, which can then release any
    * resources that the successful operation allocated.
    *
    * The call to `cleanUp` should not throw. If it does, the error will be an
    * uncaught asynchronous error.
    */
   static Future<List<T>> wait<T>(Iterable<Future<T>> futures,
-                           {bool eagerError: false,
-                            void cleanUp(T successValue)}) {
+      {bool eagerError: false, void cleanUp(T successValue)}) {
     final _Future<List<T>> result = new _Future<List<T>>();
-    List<T> values;  // Collects the values. Set to null on error.
-    int remaining = 0;  // How many futures are we waiting for.
-    var error;   // The first error from a future.
-    StackTrace stackTrace;  // The stackTrace that came with the error.
+    List<T> values; // Collects the values. Set to null on error.
+    int remaining = 0; // How many futures are we waiting for.
+    var error; // The first error from a future.
+    StackTrace stackTrace; // The stackTrace that came with the error.
 
     // Handle an error from any of the futures.
     // TODO(jmesserly): use `void` return type once it can be inferred for the
     // `then` call below.
     handleError(theError, theStackTrace) {
       remaining--;
       if (values != null) {
         if (cleanUp != null) {
           for (var value in values) {
             if (value != null) {
               // Ensure errors from cleanUp are uncaught.
-              new Future.sync(() { cleanUp(value); });
+              new Future.sync(() {
+                cleanUp(value);
+              });
             }
           }
         }
         values = null;
         if (remaining == 0 || eagerError) {
           result._completeError(theError, theStackTrace);
         } else {
           error = theError;
           stackTrace = theStackTrace;
         }
@@ skipping 10 matching lines @@
         future.then((T value) {
           remaining--;
           if (values != null) {
             values[pos] = value;
             if (remaining == 0) {
               result._completeWithValue(values);
             }
           } else {
             if (cleanUp != null && value != null) {
               // Ensure errors from cleanUp are uncaught.
-              new Future.sync(() { cleanUp(value); });
+              new Future.sync(() {
+                cleanUp(value);
+              });
             }
             if (remaining == 0 && !eagerError) {
               result._completeError(error, stackTrace);
             }
           }
         }, onError: handleError);
         // Increment the 'remaining' after the call to 'then'.
         // If that call throws, we don't expect any future callback from
         // the future, and we also don't increment remaining.
         remaining++;
@@ skipping 41 matching lines @@
     };
     var onError = (error, stack) {
       if (!completer.isCompleted) completer.completeError(error, stack);
     };
     for (var future in futures) {
       future.then(onValue, onError: onError);
     }
     return completer.future;
   }
 
-
   /**
    * Perform an async operation for each element of the iterable, in turn.
    *
    * Runs [f] for each element in [input] in order, moving to the next element
    * only when the [Future] returned by [f] completes. Returns a [Future] that
    * completes when all elements have been processed.
    *
    * The return values of all [Future]s are discarded. Any errors will cause the
    * iteration to stop and will be piped through the returned [Future].
    *
@@ skipping 23 matching lines @@
    * The [f] function must return either a `bool` value or a [Future] completing
    * with a `bool` value.
    */
   static Future doWhile(f()) {
     _Future doneSignal = new _Future();
     var nextIteration;
     // Bind this callback explicitly so that each iteration isn't bound in the
     // context of all the previous iterations' callbacks.
     nextIteration = Zone.current.bindUnaryCallback((bool keepGoing) {
       if (keepGoing) {
-        new Future.sync(f).then(nextIteration,
-                                onError: doneSignal._completeError);
+        new Future.sync(f)
+            .then(nextIteration, onError: doneSignal._completeError);
       } else {
         doneSignal._complete(null);
       }
     }, runGuarded: true);
     nextIteration(true);
     return doneSignal;
   }
 
   /**
    * Register callbacks to be called when this future completes.
@@ skipping 27 matching lines @@
    * the future returned by `then` will be completed with
    * the same result as the future returned by the callback.
    *
    * If [onError] is not given, and this future completes with an error,
    * the error is forwarded directly to the returned future.
    *
    * In most cases, it is more readable to use [catchError] separately, possibly
    * with a `test` parameter, instead of handling both value and error in a
    * single [then] call.
    */
-  Future<S> then<S>(FutureOr<S> onValue(T value), { Function onError });
+  Future<S> then<S>(FutureOr<S> onValue(T value), {Function onError});
 
   /**
    * Handles errors emitted by this [Future].
    *
    * This is the asynchronous equivalent of a "catch" block.
    *
    * Returns a new [Future] that will be completed with either the result of
    * this future or the result of calling the `onError` callback.
    *
    * If this future completes with a value,
@@ skipping 40 matching lines @@
    *     }
    *
    */
   // The `Function` below stands for one of two types:
   // - (dynamic) -> FutureOr<T>
   // - (dynamic, StackTrace) -> FutureOr<T>
   // Given that there is a `test` function that is usually used to do an
   // `isCheck` we should also expect functions that take a specific argument.
   // Note: making `catchError` return a `Future<T>` in non-strong mode could be
   // a breaking change.
-  Future<T> catchError(Function onError,
-                       {bool test(Object error)});
+  Future<T> catchError(Function onError, {bool test(Object error)});
 
   /**
    * Register a function to be called when this future completes.
    *
    * The [action] function is called when this future completes, whether it
    * does so with a value or with an error.
    *
    * This is the asynchronous equivalent of a "finally" block.
    *
    * The future returned by this call, `f`, will complete the same way
@@ skipping 109 matching lines @@
  *         _completer.complete(result);
  *       }
  *
  *       // If something goes wrong, call this.
  *       void _errorHappened(error) {
  *         _completer.completeError(error);
  *       }
  *     }
  */
 abstract class Completer<T> {
-
   /**
    * Creates a new completer.
    *
    * The general workflow for creating a new future is to 1) create a
    * new completer, 2) hand out its future, and, at a later point, 3) invoke
    * either [complete] or [completeError].
    *
    * The completer completes the future asynchronously. That means that
    * callbacks registered on the future, are not called immediately when
    * [complete] or [completeError] is called. Instead the callbacks are
@@ skipping 114 matching lines @@
   AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
   if (replacement != null) {
     error = _nonNullError(replacement.error);
     stackTrace = replacement.stackTrace;
   }
   result._completeError(error, stackTrace);
 }
 
 /** Helper function that converts `null` to a [NullThrownError]. */
 Object _nonNullError(Object error) => error ?? new NullThrownError();