Format all dart: library files

sdk/lib/isolate/isolate.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.
 
 /**
  * Concurrent programming using _isolates_:
  * independent workers that are similar to threads
  * but don't share memory,
  * communicating only via messages.
  *
@@ skipping 115 matching lines @@
    * Example:
    * ```dart
    * Isolate isolate = findSomeIsolate();
    * Isolate restrictedIsolate = new Isolate(isolate.controlPort);
    * untrustedCode(restrictedIsolate);
    * ```
    * This example creates a new `Isolate` object that cannot be used to
    * pause or terminate the isolate. All the untrusted code can do is to
    * inspect the isolate and see uncaught errors or when it terminates.
    */
-  Isolate(this.controlPort, {this.pauseCapability,
-                             this.terminateCapability});
+  Isolate(this.controlPort, {this.pauseCapability, this.terminateCapability});
 
   /**
    * Return an [Isolate] object representing the current isolate.
    *
    * The current isolate for code using [current]
    * is the isolate running the code.
    *
    * The isolate object provides the capabilities required to inspect,
    * pause or kill the isolate, and allows granting these capabilities
    * to others.
@@ skipping 71 matching lines @@
    *
    * You can also call the [setErrorsFatal], [addOnExitListener] and
    * [addErrorListener] methods on the returned isolate, but unless the
    * isolate was started as [paused], it may already have terminated
    * before those methods can complete.
    *
    * Returns a future which will complete with an [Isolate] instance if the
    * spawning succeeded. It will complete with an error otherwise.
    */
   external static Future<Isolate> spawn(void entryPoint(message), var message,
-                                        {bool paused: false,
-                                         bool errorsAreFatal,
-                                         SendPort onExit,
-                                         SendPort onError});
+      {bool paused: false,
+      bool errorsAreFatal,
+      SendPort onExit,
+      SendPort onError});
 
   /**
    * Creates and spawns an isolate that runs the code from the library with
    * the specified URI.
    *
    * The isolate starts executing the top-level `main` function of the library
    * with the given URI.
    *
    * The target `main` must be callable with zero, one or two arguments.
    * Examples:
@@ skipping 58 matching lines @@
    * If `environment` is omitted, the spawned isolate has the same environment
    * declarations as the spawning isolate.
    *
    * WARNING: The [environment] parameter is not implemented on all
    * platforms yet.
    *
    * Returns a future that will complete with an [Isolate] instance if the
    * spawning succeeded. It will complete with an error otherwise.
    */
   external static Future<Isolate> spawnUri(
-      Uri uri,
-      List<String> args,
-      var message,
+      Uri uri, List<String> args, var message,
       {bool paused: false,
-       SendPort onExit,
-       SendPort onError,
-       bool errorsAreFatal,
-       bool checked,
-       Map<String, String> environment,
-       Uri packageRoot,
-       Uri packageConfig,
-       bool automaticPackageResolution: false});
+      SendPort onExit,
+      SendPort onError,
+      bool errorsAreFatal,
+      bool checked,
+      Map<String, String> environment,
+      Uri packageRoot,
+      Uri packageConfig,
+      bool automaticPackageResolution: false});
 
   /**
    * Requests the isolate to pause.
    *
    * When the isolate receives the pause command, it stops
    * processing events from the event loop queue.
    * It may still add new events to the queue in response to, e.g., timers
    * or receive-port messages. When the isolate is resumed,
    * it starts handling the already enqueued events.
    *
@@ skipping 157 matching lines @@
    *
    * * `IMMEDIATE`: The isolate responds as soon as it receives the
    *     control message. This is after any previous control message
    *     from the same isolate has been received and processed,
    *     but may be during execution of another event.
    * * `BEFORE_NEXT_EVENT`: The response is scheduled for the next time
    *     control returns to the event loop of the receiving isolate,
    *     after the current event, and any already scheduled control events,
    *     are completed.
    */
-  external void ping(SendPort responsePort, {Object response,
-                                             int priority: IMMEDIATE});
+  external void ping(SendPort responsePort,
+      {Object response, int priority: IMMEDIATE});
 
   /**
    * Requests that uncaught errors of the isolate are sent back to [port].
    *
    * The errors are sent back as two elements lists.
    * The first element is a `String` representation of the error, usually
    * created by calling `toString` on the error.
    * The second element is a `String` representation of an accompanying
    * stack trace, or `null` if no stack trace was provided.
    * To convert this back to a [StackTrace] object, use [StackTrace.fromString].
@@ skipping 41 matching lines @@
    */
   Stream get errors {
     StreamController controller;
     RawReceivePort port;
     void handleError(message) {
       String errorDescription = message[0];
       String stackDescription = message[1];
       var error = new RemoteError(errorDescription, stackDescription);
       controller.addError(error, error.stackTrace);
     }
+
     controller = new StreamController.broadcast(
         sync: true,
         onListen: () {
           port = new RawReceivePort(handleError);
           this.addErrorListener(port.sendPort);
         },
         onCancel: () {
           this.removeErrorListener(port.sendPort);
           port.close();
           port = null;
         });
     return controller.stream;
   }
 }
 
 /**
  * Sends messages to its [ReceivePort]s.
  *
  * [SendPort]s are created from [ReceivePort]s. Any message sent through
  * a [SendPort] is delivered to its corresponding [ReceivePort]. There might be
  * many [SendPort]s for the same [ReceivePort].
  *
  * [SendPort]s can be transmitted to other isolates, and they preserve equality
  * when sent.
  */
 abstract class SendPort implements Capability {
-
   /**
    * Sends an asynchronous [message] through this send port, to its
    * corresponding `ReceivePort`.
    *
    * The content of [message] can be: primitive values (null, num, bool, double,
    * String), instances of [SendPort], and lists and maps whose elements are any
    * of these. List and maps are also allowed to be cyclic.
    *
    * In the special circumstances when two isolates share the same code and are
    * running in the same process (e.g. isolates created via [Isolate.spawn]), it
    * is also possible to send object instances (which would be copied in the
    * process). This is currently only supported by the dartvm.  For now, the
    * dart2js compiler only supports the restricted messages described above.
    *
    * The send happens immediately and doesn't block.  The corresponding receive
    * port can receive the message as soon as its isolate's event loop is ready
    * to deliver it, independently of what the sending isolate is doing.
    */
   void send(var message);
 
   /**
    * Tests whether [other] is a [SendPort] pointing to the same
    * [ReceivePort] as this one.
    */
-  bool operator==(var other);
+  bool operator ==(var other);
 
   /**
    * Returns an immutable hash code for this send port that is
    * consistent with the == operator.
    */
   int get hashCode;
 }
 
 /**
  * Together with [SendPort], the only means of communication between isolates.
  *
  * [ReceivePort]s have a `sendPort` getter which returns a [SendPort].
  * Any message that is sent through this [SendPort]
  * is delivered to the [ReceivePort] it has been created from. There, the
  * message is dispatched to the `ReceivePort`'s listener.
  *
  * A [ReceivePort] is a non-broadcast stream. This means that it buffers
  * incoming messages until a listener is registered. Only one listener can
  * receive messages. See [Stream.asBroadcastStream] for transforming the port
  * to a broadcast stream.
  *
  * A [ReceivePort] may have many [SendPort]s.
  */
 abstract class ReceivePort implements Stream {
-
   /**
    * Opens a long-lived port for receiving messages.
    *
    * A [ReceivePort] is a non-broadcast stream. This means that it buffers
    * incoming messages until a listener is registered. Only one listener can
    * receive messages. See [Stream.asBroadcastStream] for transforming the port
    * to a broadcast stream.
    *
    * A receive port is closed by canceling its subscription.
    */
@@ skipping 10 matching lines @@
   /**
    * Inherited from [Stream].
    *
    * Note that [onError] and [cancelOnError] are ignored since a ReceivePort
    * will never receive an error.
    *
    * The [onDone] handler will be called when the stream closes.
    * The stream closes when [close] is called.
    */
   StreamSubscription listen(void onData(var message),
-                            { Function onError,
-                              void onDone(),
-                              bool cancelOnError });
+      {Function onError, void onDone(), bool cancelOnError});
 
   /**
    * Closes `this`.
    *
    * If the stream has not been canceled yet, adds a close-event to the event
    * queue and discards any further incoming messages.
    *
    * If the stream has already been canceled this method has no effect.
    */
   void close();
@@ skipping 41 matching lines @@
  * as the original error, but has no other features of the original error.
  */
 class RemoteError implements Error {
   final String _description;
   final StackTrace stackTrace;
   RemoteError(String description, String stackDescription)
       : _description = description,
         stackTrace = new StackTrace.fromString(stackDescription);
   String toString() => _description;
 }