Add FutureGroup.onIdle and FutureGroup.isIdle.

lib/src/future_group.dart

 // Copyright (c) 2015, 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.
 
 library async.future_group;
 
 import 'dart:async';
 
 /// A collection of futures waits until all added [Future]s complete.
 ///
@@ skipping 17 matching lines @@
   var _closed = false;
 
   /// The future that fires once [close] has been called and all futures in the
   /// group have completed.
   ///
   /// This will also complete with an error if any of the futures in the group
   /// fails, regardless of whether [close] was called.
   Future<List<T>> get future => _completer.future;
   final _completer = new Completer<List<T>>();
 
+  /// Whether this group is waiting on any futures.
+  bool get isIdle => _pending == 0;
+
+  /// A broadcast stream that emits a `null` event whenever the last pending
+  /// future in this group completes.
+  ///
+  /// Once this group isn't waiting on any futures *and* [close] has been
+  /// called, this stream will close.
+  Stream get onIdle => _onIdleController.stream;
+  final _onIdleController = new StreamController.broadcast(sync: true);

[Lasse Reichstein Nielsen, 2015/07/02 09:18:35]

Could it be worth it to only create this controller the first time onIdle is
read? It means some "if (_onIdleController != null)" guards below, but it avoids
creating a controller if it isn't used.

[nweiz, 2015/07/06 20:23:18]

Done.

+
   /// The values emitted by the futures that have been added to the group, in
   /// the order they were added.
   ///
   /// The slots for futures that haven't completed yet are `null`.
   final _values = new List<T>();
 
   /// Wait for [task] to complete.
   void add(Future<T> task) {
     if (_closed) throw new StateError("The FutureGroup is closed.");
 
     // Ensure that future values are put into [values] in the same order they're
     // added to the group by pre-allocating a slot for them and recording its
     // index.
     var index = _values.length;
     _values.add(null);
 
     _pending++;
     task.then((value) {
       if (_completer.isCompleted) return;
 
       _pending--;
       _values[index] = value;
 
-      if (_pending == 0 && _closed) _completer.complete(_values);
+      if (_pending != 0) return;
+      _onIdleController.add(null);
+
+      if (!_closed) return;
+      _onIdleController.close();
+      _completer.complete(_values);
     }).catchError((error, stackTrace) {
       if (_completer.isCompleted) return;
       _completer.completeError(error, stackTrace);
     });
   }
 
   /// Signals to the group that the caller is done adding futures, and so
   /// [future] should fire once all added futures have completed.
   void close() {
     _closed = true;
     if (_pending != 0) return;
     if (_completer.isCompleted) return;
     _completer.complete(_values);
   }
 }