OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file |
| 2 // for details. All rights reserved. Use of this source code is governed by a |
| 3 // BSD-style license that can be found in the LICENSE file. |
| 4 |
| 5 import 'dart:async'; |
| 6 |
| 7 import '../stream_channel.dart'; |
| 8 |
| 9 /// A controller for exposing a new [StreamChannel]. |
| 10 /// |
| 11 /// This exposes two connected [StreamChannel]s, [local] and [foreign]. The |
| 12 /// user's code should use [local] to emit and receive events. Then [foreign] |
| 13 /// can be returned for others to use. For example, here's a simplified version |
| 14 /// of the implementation of [new IsolateChannel]: |
| 15 /// |
| 16 /// ```dart |
| 17 /// StreamChannel isolateChannel(ReceivePort receivePort, SendPort sendPort) { |
| 18 /// var controller = new StreamChannelController(); |
| 19 /// |
| 20 /// // Pipe all events from the receive port into the local sink... |
| 21 /// receivePort.pipe(controller.local.sink); |
| 22 /// |
| 23 /// // ...and all events from the local stream into the send port. |
| 24 /// controller.local.listen(sendPort.add, onDone: receivePort.close); |
| 25 /// |
| 26 /// // Then return the foreign controller for your users to use. |
| 27 /// return controller.foreign; |
| 28 /// } |
| 29 /// ``` |
| 30 class StreamChannelController<T> { |
| 31 /// The local channel. |
| 32 /// |
| 33 /// This channel should be used directly by the creator of this |
| 34 /// [StreamChannelController] to send and receive events. |
| 35 StreamChannel<T> get local => _local; |
| 36 StreamChannel<T> _local; |
| 37 |
| 38 /// The foreign channel. |
| 39 /// |
| 40 /// This channel should be returned to external users so they can communicate |
| 41 /// with [local]. |
| 42 StreamChannel<T> get foreign => _foreign; |
| 43 StreamChannel<T> _foreign; |
| 44 |
| 45 /// Creates a [StreamChannelController]. |
| 46 /// |
| 47 /// If [sync] is true, events added to either channel's sink are synchronously |
| 48 /// dispatched to the other channel's stream. This should only be done if the |
| 49 /// source of those events is already asynchronous. |
| 50 StreamChannelController({bool sync: false}) { |
| 51 var localToForeignController = new StreamController<T>(sync: sync); |
| 52 var foreignToLocalController = new StreamController<T>(sync: sync); |
| 53 _local = new StreamChannel<T>.withGuarantees( |
| 54 foreignToLocalController.stream, localToForeignController.sink); |
| 55 _foreign = new StreamChannel<T>.withGuarantees( |
| 56 localToForeignController.stream, foreignToLocalController.sink); |
| 57 } |
| 58 } |
OLD | NEW |