Proposal for new Isolate library.

sdk/lib/isolate/isolate_stream.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.isolate;
-
-/**
- * The initial IsolateStream available by default for this isolate.
- *
- * This IsolateStream is created automatically and is commonly used
- * to establish the first communication between isolates.
- * (See [streamSpawnFunction].)
- */
-final IsolateStream stream = new IsolateStream._fromOriginalReceivePort(port);
-
-/**
- * The creator of the [IsolateStream] and [IsolateSink]
- * that allow an isolate to exchange messages with other isolates.
- *
- * Any message that is written into the [sink] (independent of the isolate) is
- * sent to the [stream] where its subscribers can react to the messages.
- */
-class MessageBox {
-  final IsolateStream stream;
-  final IsolateSink sink;
-
-  external MessageBox.oneShot();
-  external MessageBox();
-}
-
-external bool _isCloseToken(var object);
-
-/**
- * Together with [IsolateSink], the only means of
- * communication between isolates.
- *
- * Each IsolateStream has a corresponding
- * [IsolateSink]. Any message written into that sink will be delivered to
- * the stream and then dispatched to the stream's subscribers.
- */
-class IsolateStream extends Stream<dynamic> {
-  bool _isClosed = false;
-  final ReceivePort _port;
-  StreamController _controller = new StreamController(sync: true);
-
-  IsolateStream._fromOriginalReceivePort(this._port) {
-    _port.receive((message, replyTo) {
-      assert(replyTo == null);
-      _add(message);
-    });
-  }
-
-  IsolateStream._fromOriginalReceivePortOneShot(this._port) {
-    _port.receive((message, replyTo) {
-      assert(replyTo == null);
-      _add(message);
-      close();
-    });
-  }
-
-  void _add(var message) {
-    if (_isCloseToken(message)) {
-      close();
-    } else {
-      _controller.sink.add(message);
-    }
-  }
-
-  /**
-   * Closes the stream from the receiving end.
-   *
-   * Closing an already closed port has no effect.
-   */
-  void close() {
-    if (!_isClosed) {
-      _isClosed = true;
-      _port.close();
-      _controller.close();
-    }
-  }
-
-  StreamSubscription listen(void onData(event),
-                            { void onError(error),
-                              void onDone(),
-                              bool cancelOnError}) {
-      return _controller.stream.listen(onData,
-                                       onError: onError,
-                                       onDone: onDone,
-                                       cancelOnError: cancelOnError);
-  }
-}
-
-/**
- * The feed for an [IsolateStream].
- * 
- * Any message written to [this] is delivered
- * to its respective [IsolateStream].
- * [IsolateSink]s are created by [MessageBox]es.
- *
- * [IsolateSink]s can be transmitted to other isolates.
- */
-abstract class IsolateSink extends EventSink<dynamic> {
-  // TODO(floitsch): Actually it should be a StreamSink (being able to flow-
-  // control).
-
-  /**
-   * Sends an asynchronous [message] to the linked [IsolateStream];
-   * the message is copied to the receiving isolate.
-   *
-   * The content of [message] can be: primitive values (null, num, bool, double,
-   * String), instances of [IsolateSink]s, 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 [spawnFunction]), 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.
-   */
-  void add(dynamic message);
-
-  void addError(errorEvent);
-
-  /** Closing multiple times is allowed. */
-  void close();
-
-  /**
-   * Tests whether [other] is an [IsolateSink] feeding into the same
-   * [IsolateStream] as this one.
-   */
-  bool operator==(var other);
-}
-
-
-/**
- * Creates and spawns an isolate that shares the same code as the current
- * isolate, but that starts from the specified function.
- * 
- * The [topLevelFunction] argument must be
- * a static top-level function or a static method that takes no arguments.
- *
- * When any isolate starts (even the main script of the application), a default
- * [IsolateStream] is created for it. This sink is available from the top-level
- * getter [stream] defined in this library.
- *
- * [spawnFunction] returns an [IsolateSink] feeding into the child isolate's
- * default stream.
- *
- * The optional [unhandledExceptionCallback] argument is invoked whenever an
- * exception inside the isolate is unhandled. It can be seen as a big
- * `try/catch` around everything that is executed inside the isolate. The
- * callback should return `true` if it was able to handle the exception.
- */
-external IsolateSink streamSpawnFunction(
-    void topLevelFunction(),
-    [bool unhandledExceptionCallback(IsolateUnhandledException e)]);