adding codereview file, formatting, adding gitignore

lib/loadbalancer.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.
 
 /**
  * A load-balancing runner pool.
  */
 library dart.pkg.isolate.loadbalancer;
 
 import "runner.dart";
@@ skipping 38 matching lines @@
 
   /**
    * Asynchronously create [size] runners and create a `LoadBalancer` of those.
    *
    * This is a helper function that makes it easy to create a `LoadBalancer`
    * with asynchronously created runners, for example:
    *
    *     var isolatePool = LoadBalancer.create(10, IsolateRunner.spawn);
    */
   static Future<LoadBalancer> create(int size, Future<Runner> createRunner()) {
-    return Future.wait(new Iterable.generate(size, (_) => createRunner()),
-                       cleanUp: (Runner runner) { runner.close(); })
-           .then((runners) => new LoadBalancer(runners));
+    return Future
+        .wait(new Iterable.generate(size, (_) => createRunner()),
+            cleanUp: (Runner runner) {

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

indent cleanUp to after the '('. Putting the body on three lines seems
unnecessary.

+      runner.close();
+    }).then((runners) => new LoadBalancer(runners));
   }
 
   static List<_LoadBalancerEntry> _createEntries(Iterable<Runner> runners) {
     var entries = runners.map((runner) => new _LoadBalancerEntry(runner));
     return new List<_LoadBalancerEntry>.from(entries, growable: false);
   }
 
   /**
    * Execute the command in the currently least loaded isolate.
    *
    * The optional [load] parameter represents the load that the command
    * is causing on the isolate where it runs.
    * The number has no fixed meaning, but should be seen as relative to
    * other commands run in the same load balancer.
    * The `load` must not be negative.
    *
    * If [timeout] and [onTimeout] are provided, they are forwarded to
    * the runner running the function, which will handle a timeout
    * as normal.
    */
-  Future run(function(argument), argument, {Duration timeout,
-                                            onTimeout(),
-                                            int load: 100}) {
+  Future run(function(argument), argument,
+      {Duration timeout, onTimeout(), int load: 100}) {

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

Indent "{" to after then "(". That is:
Future run(function...,
           {Duration timeout, ... }) {

     RangeError.checkNotNegative(load, "load");
     _LoadBalancerEntry entry = _first;
     _increaseLoad(entry, load);
     return entry.run(this, load, function, argument, timeout, onTimeout);
   }
 
   /**
    * Execute the same function in the least loaded [count] isolates.
    *
    * This guarantees that the function isn't run twice in the same isolate,
    * so `count` is not allowed to exceed [length].
    *
    * The optional [load] parameter represents the load that the command
    * is causing on the isolate where it runs.
    * The number has no fixed meaning, but should be seen as relative to
    * other commands run in the same load balancer.
    * The `load` must not be negative.
    *
    * If [timeout] and [onTimeout] are provided, they are forwarded to
    * the runners running the function, which will handle any timeouts
    * as normal.
    */
   List<Future> runMultiple(int count, function(argument), argument,
-                           {Duration timeout,
-                            onTimeout(),
-                            int load: 100}) {
+      {Duration timeout, onTimeout(), int load: 100}) {

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

Indent '{ ' to after '('.

     RangeError.checkValueInInterval(count, 1, _length, "count");
     RangeError.checkNotNegative(load, "load");
     if (count == 1) {
-      return list1(run(function, argument, load: load,
-                       timeout: timeout, onTimeout: onTimeout));
+      return list1(run(function, argument,
+          load: load, timeout: timeout, onTimeout: onTimeout));

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

Indent arguments to after '(' or put all arguments on new lines.

     }
     List result = new List<Future>(count);
     if (count == _length) {
       // No need to change the order of entries in the queue.
       for (int i = 0; i < count; i++) {
         _LoadBalancerEntry entry = _queue[i];
         entry.load += load;
-        result[i] = entry.run(this, load, function, argument,
-                              timeout, onTimeout);
+        result[i] =
+            entry.run(this, load, function, argument, timeout, onTimeout);
       }
     } else {
       // Remove the [count] least loaded services and run the
       // command on each, then add them back to the queue.
       // This avoids running the same command twice in the same
       // isolate.
       List entries = new List(count);
       for (int i = 0; i < count; i++) {
         entries[i] = _removeFirst();
       }
       for (int i = 0; i < count; i++) {
         _LoadBalancerEntry entry = entries[i];
         entry.load += load;
         _add(entry);
-        result[i] = entry.run(this, load, function, argument,
-                              timeout, onTimeout);
+        result[i] =
+            entry.run(this, load, function, argument, timeout, onTimeout);
       }
     }
     return result;
   }
 
   Future close() {
     if (_stopFuture != null) return _stopFuture;
-    _stopFuture = MultiError.waitUnordered(_queue.take(_length)
-                                                 .map((e) => e.close()));
+    _stopFuture =
+        MultiError.waitUnordered(_queue.take(_length).map((e) => e.close()));
     // Remove all entries.
     for (int i = 0; i < _length; i++) _queue[i].queueIndex = -1;
     _queue = null;
     _length = 0;
     return _stopFuture;
   }
 
   /**
    * Place [element] in heap at [index] or above.
    *
@@ skipping 16 matching lines @@
 
   /**
    * Place [element] in heap at [index] or above.
    *
    * Put element into the empty cell at `index`.
    * While the `element` has lower priority than either child,
    * swap it with the highest priority child.
    */
   void _bubbleDown(_LoadBalancerEntry element, int index) {
     while (true) {
-      int childIndex = index * 2 + 1;  // Left child index.
+      int childIndex = index * 2 + 1; // Left child index.

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

There should always be two spaces before an end-of-line comment on a code line.

       if (childIndex >= _length) break;
       _LoadBalancerEntry child = _queue[childIndex];
       int rightChildIndex = childIndex + 1;
       if (rightChildIndex < _length) {
         _LoadBalancerEntry rightChild = _queue[rightChildIndex];
         if (rightChild.compareTo(child) < 0) {
           childIndex = rightChildIndex;
           child = rightChild;
         }
       }
@@ skipping 79 matching lines @@
 class _LoadBalancerEntry implements Comparable<_LoadBalancerEntry> {
   // The current load on the isolate.
   int load = 0;
   // The current index in the heap-queue.
   // Negative when the entry is not part of the queue.
   int queueIndex = -1;
 
   // The service used to send commands to the other isolate.
   Runner runner;
 
-  _LoadBalancerEntry(Runner runner)
-      : runner = runner;
+  _LoadBalancerEntry(Runner runner) : runner = runner;
 
   /** Whether the entry is still in the queue. */
   bool get inQueue => queueIndex >= 0;
 
   Future run(LoadBalancer balancer, int load, function(argumen), argument,
-             Duration timeout, onTimeout()) {
-    return runner.run(function, argument,
-                      timeout: timeout, onTimeout: onTimeout).whenComplete(() {
+      Duration timeout, onTimeout()) {
+    return runner
+        .run(function, argument, timeout: timeout, onTimeout: onTimeout)
+        .whenComplete(() {
       balancer._decreaseLoad(this, load);

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

Indent body by four more.

     });
   }
 
   Future close() => runner.close();
 
   int compareTo(_LoadBalancerEntry other) => load - other.load;
 }
-
-