Renamed StreamSink to EventSink. Renamed signalError to addError.

sdk/lib/async/stream_impl.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.async;
 
 // States shared by single/multi stream implementations.
 
 // Completion state of the stream.
 /// Initial and default state where the stream can receive and send events.
@@ skipping 48 matching lines @@
 // -------------------------------------------------------------------
 // Common base class for single and multi-subscription streams.
 // -------------------------------------------------------------------
 abstract class _StreamImpl<T> extends Stream<T> {
   /** Current state of the stream. */
   int _state = _STREAM_OPEN;
 
   /**
    * List of pending events.
    *
-   * If events are added to the stream (using [_add], [_signalError] or [_done])
+   * If events are added to the stream (using [_add], [_addError] or [_done])
    * while the stream is paused, or while another event is firing, events will
    * stored here.
    * Also supports scheduling the events for later execution.
    */
   _PendingEvents _pendingEvents;
 
   // ------------------------------------------------------------------
   // Stream interface.
 
   StreamSubscription<T> listen(void onData(T data),
                                { void onError(AsyncError error),
                                  void onDone(),
                                  bool unsubscribeOnError }) {
     if (_isComplete) {
       return new _DoneSubscription(onDone);
     }
     if (onData == null) onData = _nullDataHandler;
     if (onError == null) onError = _nullErrorHandler;
     if (onDone == null) onDone = _nullDoneHandler;
     unsubscribeOnError = identical(true, unsubscribeOnError);
     _StreamSubscriptionImpl subscription =
         _createSubscription(onData, onError, onDone, unsubscribeOnError);
     _addListener(subscription);
     return subscription;
   }
 
   // ------------------------------------------------------------------
-  // StreamSink interface-like methods for sending events into the stream.
+  // EventSink interface-like methods for sending events into the stream.
   // It's the responsibility of the caller to ensure that the stream is not
   // paused when adding events. If the stream is paused, the events will be
   // queued, but it's better to not send events at all.
 
   /**
    * Send or queue a data event.
    */
   void _add(T value) {
     if (_isClosed) throw new StateError("Sending on closed stream");
     if (!_mayFireState) {
       // Not the time to send events.
       _addPendingEvent(new _DelayedData<T>(value));
       return;
     }
     if (_hasPendingEvent) {
       _addPendingEvent(new _DelayedData<T>(value));
     } else {
       _sendData(value);
     }
     _handlePendingEvents();
   }
 
   /**
    * Send or enqueue an error event.
    *
    * If a subscription has requested to be unsubscribed on errors,
    * it will be unsubscribed after receiving this event.
    */
-  void _signalError(AsyncError error) {
+  void _addError(AsyncError error) {
     if (_isClosed) throw new StateError("Sending on closed stream");
     if (!_mayFireState) {
       // Not the time to send events.
       _addPendingEvent(new _DelayedError(error));
       return;
     }
     if (_hasPendingEvent) {
       _addPendingEvent(new _DelayedError(error));
     } else {
       _sendError(error);
@@ skipping 418 matching lines @@
  *
  * The only public methods are those of [Stream], so instances of
  * [_SingleStreamImpl] can be returned directly as a [Stream] without exposing
  * internal functionality.
  *
  * The [StreamController] is a public facing version of this class, with
  * some methods made public.
  *
  * The user interface of [_SingleStreamImpl] are the following methods:
  * * [_add]: Add a data event to the stream.
- * * [_signalError]: Add an error event to the stream.
+ * * [_addError]: Add an error event to the stream.
  * * [_close]: Request to close the stream.
  * * [_onSubscriberStateChange]: Called when receiving the first subscriber or
  *                               when losing the last subscriber.
  * * [_onPauseStateChange]: Called when entering or leaving paused mode.
  * * [_hasSubscribers]: Test whether there are currently any subscribers.
  * * [_isInputPaused]: Test whether the stream is currently paused.
  * The user should not add new events while the stream is paused, but if it
  * happens anyway, the stream will enqueue the events just as when new events
  * arrive while still firing an old event.
  */
@@ skipping 93 matching lines @@
  *
  * The only public methods are those of [Stream], so instances of
  * [_MultiStreamImpl] can be returned directly as a [Stream] without exposing
  * internal functionality.
  *
  * The [StreamController] is a public facing version of this class, with
  * some methods made public.
  *
  * The user interface of [_MultiStreamImpl] are the following methods:
  * * [_add]: Add a data event to the stream.
- * * [_signalError]: Add an error event to the stream.
+ * * [_addError]: Add an error event to the stream.
  * * [_close]: Request to close the stream.
  * * [_onSubscriptionStateChange]: Called when receiving the first subscriber or
  *                                 when losing the last subscriber.
  * * [_onPauseStateChange]: Called when entering or leaving paused mode.
  * * [_hasSubscribers]: Test whether there are currently any subscribers.
  * * [_isPaused]: Test whether the stream is currently paused.
  * The user should not add new events while the stream is paused, but if it
  * happens anyway, the stream will enqueue the events just as when new events
  * arrive while still firing an old event.
  */
@@ skipping 144 matching lines @@
    */
   _GeneratedSingleStreamImpl(_PendingEvents events) {
     _pendingEvents = events;
     _setClosed();  // Closed for input since all events are already pending.
   }
 
   void _add(T value) {
     throw new UnsupportedError("Cannot inject events into generated stream");
   }
 
-  void _signalError(AsyncError value) {
+  void _addError(AsyncError value) {
     throw new UnsupportedError("Cannot inject events into generated stream");
   }
 
   void _close() {
     throw new UnsupportedError("Cannot inject events into generated stream");
   }
 }
 
 
 /** Pending events object that gets its events from an [Iterable]. */
@@ skipping 236 matching lines @@
     otherNext._previousLink = listLast;
     _InternalLink otherLast = other._previousLink;
     list._previousLink = otherLast;
     otherLast._nextLink = list;
     // Clean up [other].
     other._nextLink = other._previousLink = other;
   }
 }
 
 /** Abstract type for an internal interface for sending events. */
-abstract class _StreamOutputSink<T> {
+abstract class _EventOutputSink<T> {
   _sendData(T data);
   _sendError(AsyncError error);
   _sendDone();
 }
 
 abstract class _StreamListener<T> extends _InternalLink
-                                  implements _StreamOutputSink<T> {
+                                  implements _EventOutputSink<T> {
   final _StreamImpl _source;
   int _state = _LISTENER_UNSUBSCRIBED;
 
   _StreamListener(this._source);
 
   bool get isPaused => _state >= (1 << _LISTENER_PAUSE_COUNT_SHIFT);
 
   bool get _isPendingUnsubscribe =>
       (_state & _LISTENER_PENDING_UNSUBSCRIBE) != 0;
 
@@ skipping 206 matching lines @@
   }
 
   /**
     * Subscribe or unsubscribe on [_source] depending on whether
     * [_stream] has subscribers.
     */
   void _onSubscriptionStateChange() {
     if (_hasSubscribers) {
       assert(_subscription == null);
       _subscription = _source.listen(this._add,
-                                     onError: this._signalError,
+                                     onError: this._addError,
                                      onDone: this._close);
     } else {
       // TODO(lrn): Check why this can happen.
       if (_subscription == null) return;
       _subscription.cancel();
       _subscription = null;
     }
   }
 }