Rename unsubscribe to cancel.

sdk/lib/async/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.async;
 
 // -------------------------------------------------------------------
 // Core Stream types
 // -------------------------------------------------------------------
 
@@ skipping 116 matching lines @@
   /** Reduces a sequence of values by repeatedly applying [combine]. */
   Future reduce(var initialValue, combine(var previous, T element)) {
     Completer completer = new Completer();
     var value = initialValue;
     StreamSubscription subscription;
     subscription = this.listen(
       (T element) {
         try {
           value = combine(value, element);
         } catch (e, s) {
-          subscription.unsubscribe();
+          subscription.cancel();
           completer.completeError(e, s);
         }
       },
       onError: (AsyncError e) {
         completer.completeError(e.error, e.stackTrace);
       },
       onDone: () {
         completer.complete(value);
       },
       unsubscribeOnError: true);
@@ skipping 19 matching lines @@
 
   /**
    * Check whether [match] occurs in the elements provided by this stream.
    *
    * Completes the [Future] when the answer is known.
    * If this stream reports an error, the [Future] will report that error.
    */
   Future<bool> contains(T match) {
     _FutureImpl<bool> future = new _FutureImpl<bool>();
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
         (T element) {
           if (element == match) {
-            subscription.unsubscribe();
+            subscription.cancel();
             future._setValue(true);
           }
         },
         onError: future._setError,
         onDone: () {
           future._setValue(false);
         },
         unsubscribeOnError: true);
     return future;
   }
 
   /**
    * Check whether [test] accepts all elements provided by this stream.
    *
    * Completes the [Future] when the answer is known.
    * If this stream reports an error, the [Future] will report that error.
    */
   Future<bool> every(bool test(T element)) {
     _FutureImpl<bool> future = new _FutureImpl<bool>();
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
         (T element) {
           if (!test(element)) {
-            subscription.unsubscribe();
+            subscription.cancel();
             future._setValue(false);
           }
         },
         onError: future._setError,
         onDone: () {
           future._setValue(true);
         },
         unsubscribeOnError: true);
     return future;
   }
 
   /**
    * Check whether [test] accepts any element provided by this stream.
    *
    * Completes the [Future] when the answer is known.
    * If this stream reports an error, the [Future] will report that error.
    */
   Future<bool> any(bool test(T element)) {
     _FutureImpl<bool> future = new _FutureImpl<bool>();
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
         (T element) {
           if (test(element)) {
-            subscription.unsubscribe();
+            subscription.cancel();
             future._setValue(true);
           }
         },
         onError: future._setError,
         onDone: () {
           future._setValue(false);
         },
         unsubscribeOnError: true);
     return future;
   }
 
 
   /** Counts the elements in the stream. */
   Future<int> get length {
     _FutureImpl<int> future = new _FutureImpl<int>();
     int count = 0;
-    listen(
+    this.listen(
       (_) { count++; },
       onError: future._setError,
       onDone: () {
         future._setValue(count);
       },
       unsubscribeOnError: true);
     return future;
   }
 
   /**
    * Finds the least element in the stream.
    *
    * If the stream is empty, the result is [:null:].
    * Otherwise the result is a value from the stream that is not greater
    * than any other value from the stream (according to [compare], which must
    * be a [Comparator]).
    *
    * If [compare] is omitted, it defaults to [Comparable.compare].
    */
   Future<T> min([int compare(T a, T b)]) {
     if (compare == null) compare = Comparable.compare;
     _FutureImpl<T> future = new _FutureImpl<T>();
     StreamSubscription subscription;
     T min = null;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         min = value;
         subscription.onData((T value) {
           if (compare(min, value) > 0) min = value;
         });
       },
       onError: future._setError,
       onDone: () {
         future._setValue(min);
       },
@@ skipping 10 matching lines @@
    * than any other value from the stream (according to [compare], which must
    * be a [Comparator]).
    *
    * If [compare] is omitted, it defaults to [Comparable.compare].
    */
   Future<T> max([int compare(T a, T b)]) {
     if (compare == null) compare = Comparable.compare;
     _FutureImpl<T> future = new _FutureImpl<T>();
     StreamSubscription subscription;
     T max = null;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         max = value;
         subscription.onData((T value) {
           if (compare(max, value) < 0) max = value;
         });
       },
       onError: future._setError,
       onDone: () {
         future._setValue(max);
       },
       unsubscribeOnError: true
     );
     return future;
   }
 
   /** Reports whether this stream contains any elements. */
   Future<bool> get isEmpty {
     _FutureImpl<bool> future = new _FutureImpl<bool>();
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (_) {
-        subscription.unsubscribe();
+        subscription.cancel();
         future._setValue(false);
       },
       onError: future._setError,
       onDone: () {
         future._setValue(true);
       },
       unsubscribeOnError: true);
     return future;
   }
 
   /** Collect the data of this stream in a [List]. */
   Future<List<T>> toList() {
     List<T> result = <T>[];
     _FutureImpl<List<T>> future = new _FutureImpl<List<T>>();
-    listen(
+    this.listen(
       (T data) {
         result.add(data);
       },
       onError: future._setError,
       onDone: () {
         future._setValue(result);
       },
       unsubscribeOnError: true);
     return future;
   }
 
   /** Collect the data of this stream in a [Set]. */
   Future<Set<T>> toSet() {
     Set<T> result = new Set<T>();
     _FutureImpl<Set<T>> future = new _FutureImpl<Set<T>>();
-    listen(
+    this.listen(
       (T data) {
         result.add(data);
       },
       onError: future._setError,
       onDone: () {
         future._setValue(result);
       },
       unsubscribeOnError: true);
     return future;
   }
@@ skipping 57 matching lines @@
 
   /**
    * Returns the first element.
    *
    * If [this] is empty throws a [StateError]. Otherwise this method is
    * equivalent to [:this.elementAt(0):]
    */
   Future<T> get first {
     _FutureImpl<T> future = new _FutureImpl();
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         future._setValue(value);
-        subscription.unsubscribe();
+        subscription.cancel();
         return;
       },
       onError: future._setError,
       onDone: () {
         future._setError(new AsyncError(new StateError("No elements")));
       },
       unsubscribeOnError: true);
     return future;
   }
 
   /**
    * Returns the last element.
    *
    * If [this] is empty throws a [StateError].
    */
   Future<T> get last {
     _FutureImpl<T> future = new _FutureImpl<T>();
     T result = null;
     bool foundResult = false;
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         foundResult = true;
         result = value;
       },
       onError: future._setError,
       onDone: () {
         if (foundResult) {
           future._setValue(result);
           return;
         }
         future._setError(new AsyncError(new StateError("No elements")));
       },
       unsubscribeOnError: true);
     return future;
   }
 
   /**
    * Returns the single element.
    *
    * If [this] is empty or has more than one element throws a [StateError].
    */
   Future<T> get single {
     _FutureImpl<T> future = new _FutureImpl<T>();
     T result = null;
     bool foundResult = false;
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         if (foundResult) {
           // This is the second element we get.
           Error error = new StateError("More than one element");
           future._setError(new AsyncError(error));
-          subscription.unsubscribe();
+          subscription.cancel();
           return;
         }
         foundResult = true;
         result = value;
       },
       onError: future._setError,
       onDone: () {
         if (foundResult) {
           future._setValue(result);
           return;
@@ skipping 14 matching lines @@
    * [defaultValue] function is provided, the result of calling [defaultValue]
    * becomes the value of the future.
    *
    * If an error occurs, or if this stream ends without finding a match and
    * with no [defaultValue] function provided, the future will receive an
    * error.
    */
   Future<T> firstMatching(bool test(T value), {T defaultValue()}) {
     _FutureImpl<T> future = new _FutureImpl<T>();
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         bool matches;
         try {
           matches = (true == test(value));
         } catch (e, s) {
           future._setError(new AsyncError(e, s));
-          subscription.unsubscribe();
+          subscription.cancel();
           return;
         }
         if (matches) {
           future._setValue(value);
-          subscription.unsubscribe();
+          subscription.cancel();
         }
       },
       onError: future._setError,
       onDone: () {
         if (defaultValue != null) {
           T value;
           try {
             value = defaultValue();
           } catch (e, s) {
             future._setError(new AsyncError(e, s));
@@ skipping 14 matching lines @@
    *
    * As [firstMatching], except that the last matching element is found.
    * That means that the result cannot be provided before this stream
    * is done.
    */
   Future<T> lastMatching(bool test(T value), {T defaultValue()}) {
     _FutureImpl<T> future = new _FutureImpl<T>();
     T result = null;
     bool foundResult = false;
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         bool matches;
         try {
           matches = (true == test(value));
         } catch (e, s) {
           future._setError(new AsyncError(e, s));
-          subscription.unsubscribe();
+          subscription.cancel();
           return;
         }
         if (matches) {
           foundResult = true;
           result = value;
         }
       },
       onError: future._setError,
       onDone: () {
         if (foundResult) {
@@ skipping 22 matching lines @@
    * Finds the single element in this stream matching [test].
    *
    * Like [lastMatch], except that it is an error if more than one
    * matching element occurs in the stream.
    */
   Future<T> singleMatching(bool test(T value)) {
     _FutureImpl<T> future = new _FutureImpl<T>();
     T result = null;
     bool foundResult = false;
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         bool matches;
         try {
           matches = (true == test(value));
         } catch (e, s) {
           future._setError(new AsyncError(e, s));
-          subscription.unsubscribe();
+          subscription.cancel();
           return;
         }
         if (matches) {
           if (foundResult) {
             future._setError(new AsyncError(
                 new StateError('Multiple matches for "single"')));
-            subscription.unsubscribe();
+            subscription.cancel();
             return;
           }
           foundResult = true;
           result = value;
         }
       },
       onError: future._setError,
       onDone: () {
         if (foundResult) {
           future._setValue(result);
@@ skipping 10 matching lines @@
    * Returns the value of the [index]th data event of this stream.
    *
    * If an error event occurs, the future will end with this error.
    *
    * If this stream provides fewer than [index] elements before closing,
    * an error is reported.
    */
   Future<T> elementAt(int index) {
     _FutureImpl<T> future = new _FutureImpl();
     StreamSubscription subscription;
-    subscription = listen(
+    subscription = this.listen(
       (T value) {
         if (index == 0) {
           future._setValue(value);
-          subscription.unsubscribe();
+          subscription.cancel();
           return;
         }
         index -= 1;
       },
       onError: future._setError,
       onDone: () {
         future._setError(new AsyncError(
             new StateError("Not enough elements for elementAt")));
       },
       unsubscribeOnError: true);
     return future;
   }
 }
 
 /**
  * A control object for the subscription on a [Stream].
  *
  * When you subscribe on a [Stream] using [Stream.subscribe],
  * a [StreamSubscription] object is returned. This object
  * is used to later unsubscribe again, or to temporarily pause
  * the stream's events.
  */
 abstract class StreamSubscription<T> {
   /**
    * Cancels this subscription. It will no longer receive events.
    *
    * If an event is currently firing, this unsubscription will only
    * take effect after all subscribers have received the current event.
    */
-  void unsubscribe();
+  void cancel();
 
   /** Set or override the data event handler of this subscription. */
   void onData(void handleData(T data));
 
   /** Set or override the error event handler of this subscription. */
   void onError(void handleError(AsyncError error));
 
   /** Set or override the done event handler of this subscription. */
   void onDone(void handleDone());
 
@@ skipping 118 matching lines @@
     sink.signalError(error);
   }
 
   /**
    * Handle an incoming done event.
    */
   void handleDone(StreamSink<T> sink) {
     sink.close();
   }
 }