Add cleanUp function to Future.wait.

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;
 
 /**
  * An object representing a delayed computation.
  *
  * A [Future] is used to represent a potential value, or error,
@@ skipping 215 matching lines @@
     new Timer(duration, () {
       try {
         result._complete(computation == null ? null : computation());
       } catch (e, s) {
         _completeWithErrorCallback(result, e, s);
       }
     });
     return result;
   }
 
+  /** Helper function that moves try/catch out of the main wait function. */
+  static void _safeCleanUp(var value, void cleanUp(value)) {
+    try {
+      cleanUp(value);
+    } on Object {
+      // Swallow any error. We are already reporting an earlier error.
+    }
+  }
+
   /**
    * Wait for all the given futures to complete and collect their values.
    *
    * Returns a future which will complete once all the futures in a list are
    * complete. If any of the futures in the list completes with an error,
    * the resulting future also completes with an error. Otherwise the value
-   * of the returned future will be a list of all the values that were produced.
+   * of the returned future will be a list of all the values that were
+   * produced.
    *
    * If `eagerError` is true, the future completes with an error immediately on
    * the first error from one of the futures. Otherwise all futures must
    * complete before the returned future is completed (still with the first
    * error to occur, the remaining errors are silently dropped).
+   *
+   * If [cleanUp] is provided, in the case of an error, any non-null result of

[kevmoo, 2014/12/18 23:17:50]

This could be a bit more clear.

...in case of an error, all non-null results generated before the error are
passed to `cleanUp`, which can release any...

[Lasse Reichstein Nielsen, 2014/12/19 06:54:11]

Any futures completing successfully after the first error will also be passed to
cleanUp. It could do with a rewrite for clarity.

We also swallow any error after the first - we consider the n futures to be one
operation, and it fails or completes a one.

I'll see if I can make the clean-up errors become uncaught errors instead of
being swallowed. There shouldn't be any errors, so having them uncaught is
reasonable too.

+   * a successful future is passed to `cleanUp`, which can then release any
+   * resources that the successful operation allocated.
    */
-  static Future<List> wait(Iterable<Future> futures, {bool eagerError: false}) {
+  static Future<List> wait(Iterable<Future> futures,
+                           {bool eagerError: false,
+                            void cleanUp(successValue)}) {
     final _Future<List> result = new _Future<List>();
     List 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.
-    handleError(theError, theStackTrace) {
-      final bool isFirstError = (values != null);
-      values = null;
+    void handleError(theError, theStackTrace) {
       remaining--;
-      if (isFirstError) {
+      if (values != null) {
+        if (cleanUp != null) {
+          for (var value in values) {
+            if (value != null) _safeCleanUp(value, cleanUp);
+          }
+        }
+        values = null;
         if (remaining == 0 || eagerError) {
           result._completeError(theError, theStackTrace);
         } else {
           error = theError;
           stackTrace = theStackTrace;
         }
       } else if (remaining == 0 && !eagerError) {
         result._completeError(error, stackTrace);
       }
     }
 
     // As each future completes, put its value into the corresponding
     // position in the list of values.
     for (Future future in futures) {
       int pos = remaining++;
       future.then((Object value) {
         remaining--;
         if (values != null) {
           values[pos] = value;
           if (remaining == 0) {
             result._completeWithValue(values);
           }
-        } else if (remaining == 0 && !eagerError) {
-          result._completeError(error, stackTrace);
+        } else {
+          if (cleanUp != null && value != null) {
+            _safeCleanUp(value, cleanUp);
+          }
+          if (remaining == 0 && !eagerError) {
+            result._completeError(error, stackTrace);
+          }
         }
       }, onError: handleError);
     }
     if (remaining == 0) {
       return new Future.value(const []);
     }
     values = new List(remaining);
     return result;
   }
 
@@ skipping 401 matching lines @@
   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 != null) ? error : new NullThrownError();