Cleaned up all empty @return tags, too.

jmhofer · jmhofer · commit 236f59d5b58f · 2013-05-02T20:38:41.000+02:00
diff --git a/rxjava-core/src/main/java/rx/Notification.java b/rxjava-core/src/main/java/rx/Notification.java
@@ -96,9 +96,9 @@ public boolean hasException() {
     }
 
     /**
-     * The kind of notification: OnNext, OnError, OnCompleted
+     * Retrieves the kind of the notification: OnNext, OnError, OnCompleted
      * 
-     * @return
+     * @return the kind of the notification: OnNext, OnError, OnCompleted
      */
     public Kind getKind() {
         return kind;
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
@@ -2010,24 +2010,24 @@ public static <T> Observable<T> takeLast(final Observable<T> items, final int co
     }
 
     /**
-     * Returns a specified number of contiguous values from the start of an observable sequence.
+     * Returns the values from the start of an observable sequence while a given predicate remains true.
      * 
      * @param items
      * @param predicate
      *            a function to test each source element for a condition
-     * @return
+     * @return the values from the start of the given sequence 
      */
     public static <T> Observable<T> takeWhile(final Observable<T> items, Func1<T, Boolean> predicate) {
         return create(OperationTakeWhile.takeWhile(items, predicate));
     }
 
     /**
-     * Returns a specified number of contiguous values from the start of an observable sequence.
+     * Returns the values from the start of an observable sequence while a given predicate remains true.
      * 
      * @param items
      * @param predicate
      *            a function to test each source element for a condition
-     * @return
+     * @return the values from the start of the given sequence 
      */
     public static <T> Observable<T> takeWhile(final Observable<T> items, Object predicate) {
         @SuppressWarnings("rawtypes")
@@ -2047,7 +2047,7 @@ public Boolean call(T t) {
      * @param items
      * @param predicate
      *            a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
-     * @return
+     * @return the values from the start of the given sequence 
      */
     public static <T> Observable<T> takeWhileWithIndex(final Observable<T> items, Func2<T, Integer, Boolean> predicate) {
         return create(OperationTakeWhile.takeWhileWithIndex(items, predicate));
@@ -2388,7 +2388,7 @@ public static <T> Observable<T> toObservable(T... items) {
      * @param sequence
      * @throws ClassCastException
      *             if T objects do not implement Comparable
-     * @return
+     * @return an observable containing the sorted list 
      */
     public static <T> Observable<List<T>> toSortedList(Observable<T> sequence) {
         return create(OperationToObservableSortedList.toSortedList(sequence));
@@ -2401,7 +2401,7 @@ public static <T> Observable<List<T>> toSortedList(Observable<T> sequence) {
      * 
      * @param sequence
      * @param sortFunction
-     * @return
+     * @return an observable containing the sorted list 
      */
     public static <T> Observable<List<T>> toSortedList(Observable<T> sequence, Func2<T, T, Integer> sortFunction) {
         return create(OperationToObservableSortedList.toSortedList(sequence, sortFunction));
@@ -2414,7 +2414,7 @@ public static <T> Observable<List<T>> toSortedList(Observable<T> sequence, Func2
      * 
      * @param sequence
      * @param sortFunction
-     * @return
+     * @return an observable containing the sorted list 
      */
     public static <T> Observable<List<T>> toSortedList(Observable<T> sequence, final Object sortFunction) {
         @SuppressWarnings("rawtypes")
@@ -3421,18 +3421,18 @@ public Observable<T> take(final int num) {
      * 
      * @param predicate
      *            a function to test each source element for a condition
-     * @return
+     * @return the values from the start of the given sequence 
      */
     public Observable<T> takeWhile(final Func1<T, Boolean> predicate) {
         return takeWhile(this, predicate);
     }
 
     /**
-     * Returns a specified number of contiguous values from the start of an observable sequence.
+     * Returns an Observable that items emitted by the source Observable as long as a specified condition is true.
      * 
      * @param predicate
      *            a function to test each source element for a condition
-     * @return
+     * @return the values from the start of the given sequence 
      */
     public Observable<T> takeWhile(final Object predicate) {
         return takeWhile(this, predicate);
@@ -3443,7 +3443,7 @@ public Observable<T> takeWhile(final Object predicate) {
      * 
      * @param predicate
      *            a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
-     * @return
+     * @return the values from the start of the given sequence 
      */
     public Observable<T> takeWhileWithIndex(final Func2<T, Integer, Boolean> predicate) {
         return takeWhileWithIndex(this, predicate);
@@ -3454,7 +3454,7 @@ public Observable<T> takeWhileWithIndex(final Func2<T, Integer, Boolean> predica
      * 
      * @param predicate
      *            a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
-     * @return
+     * @return the values from the start of the given sequence 
      */
     public Observable<T> takeWhileWithIndex(final Object predicate) {
         return takeWhileWithIndex(this, predicate);
@@ -3525,7 +3525,7 @@ public Observable<List<T>> toList() {
      * 
      * @throws ClassCastException
      *             if T objects do not implement Comparable
-     * @return
+     * @return an observable containing the sorted list 
      */
     public Observable<List<T>> toSortedList() {
         return toSortedList(this);
@@ -3537,7 +3537,7 @@ public Observable<List<T>> toSortedList() {
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toSortedList.png">
      * 
      * @param sortFunction
-     * @return
+     * @return an observable containing the sorted list 
      */
     public Observable<List<T>> toSortedList(Func2<T, T, Integer> sortFunction) {
         return toSortedList(this, sortFunction);
@@ -3549,7 +3549,7 @@ public Observable<List<T>> toSortedList(Func2<T, T, Integer> sortFunction) {
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toSortedList.png">
      * 
      * @param sortFunction
-     * @return
+     * @return an observable containing the sorted list 
      */
     public Observable<List<T>> toSortedList(final Object sortFunction) {
         return toSortedList(this, sortFunction);
@@ -3636,7 +3636,7 @@ public Iterable<T> mostRecent(T initialValue) {
      * NOTE: If strong reasons for not depending on package names comes up then the implementation of this method can change to looking for a marker interface.
      * 
      * @param f
-     * @return
+     * @return {@code true} if the given function is an internal implementation, and {@code false} otherwise.
      */
     private boolean isInternalImplementation(Object o) {
         if (o == null) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -37,7 +37,7 @@ public final class OperationSkip {
      * 
      * @param items
      * @param num
-     * @return
+     * @return the observable sequence starting after a number of skipped values
      * 
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229847(v=vs.103).aspx">Observable.Skip(TSource) Method</a>
      */
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
@@ -52,7 +52,7 @@ public final class OperationSynchronize<T> {
      * 
      * @param observable
      * @param <T>
-     * @return
+     * @return the wrapped synchronized observable sequence
      */
     public static <T> Func1<Observer<T>, Subscription> synchronize(Observable<T> observable) {
         return new Synchronize<T>(observable);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTake.java b/rxjava-core/src/main/java/rx/operators/OperationTake.java
@@ -42,7 +42,7 @@ public final class OperationTake {
      * 
      * @param items
      * @param num
-     * @return
+     * @return the specified number of contiguous values from the start of the given observable sequence
      */
     public static <T> Func1<Observer<T>, Subscription> take(final Observable<T> items, final int num) {
         // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
@@ -40,12 +40,12 @@
 public final class OperationTakeWhile {
 
     /**
-     * Returns a specified number of contiguous values from the start of an observable sequence.
+     * Returns values from an observable sequence as long as a specified condition is true, and then skips the remaining values.
      * 
      * @param items
      * @param predicate
      *            a function to test each source element for a condition
-     * @return
+     * @return sequence of observable values from the start as long as the predicate is true
      */
     public static <T> Func1<Observer<T>, Subscription> takeWhile(final Observable<T> items, final Func1<T, Boolean> predicate) {
         return takeWhileWithIndex(items, OperationTakeWhile.<T> skipIndex(predicate));
@@ -57,7 +57,7 @@ public static <T> Func1<Observer<T>, Subscription> takeWhile(final Observable<T>
      * @param items
      * @param predicate
      *            a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
-     * @return
+     * @return sequence of observable values from the start as long as the predicate is true
      */
     public static <T> Func1<Observer<T>, Subscription> takeWhileWithIndex(final Observable<T> items, final Func2<T, Integer, Boolean> predicate) {
         // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java
@@ -47,7 +47,7 @@ public final class OperationToObservableSortedList<T> {
      * @param sequence
      * @throws ClassCastException
      *             if T objects do not implement Comparable
-     * @return
+     * @return an observable containing the sorted list
      */
     public static <T> Func1<Observer<List<T>>, Subscription> toSortedList(Observable<T> sequence) {
         return new ToObservableSortedList<T>(sequence);
@@ -58,7 +58,7 @@ public static <T> Func1<Observer<List<T>>, Subscription> toSortedList(Observable
      * 
      * @param sequence
      * @param sortFunction
-     * @return
+     * @return an observable containing the sorted list
      */
     public static <T> Func1<Observer<List<T>>, Subscription> toSortedList(Observable<T> sequence, Func2<T, T, Integer> sortFunction) {
         return new ToObservableSortedList<T>(sequence, sortFunction);

Original file line number	Diff line number	Diff line change
`@@ -96,9 +96,9 @@ public boolean hasException() {`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`/**`
`99`		`- * The kind of notification: OnNext, OnError, OnCompleted`
	`99`	`+ * Retrieves the kind of the notification: OnNext, OnError, OnCompleted`
`100`	`100`	`*`
`101`		`- * @return`
	`101`	`+ * @return the kind of the notification: OnNext, OnError, OnCompleted`
`102`	`102`	`*/`
`103`	`103`	`public Kind getKind() {`
`104`	`104`	`return kind;`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public final class OperationSkip {`
`37`	`37`	`*`
`38`	`38`	`* @param items`
`39`	`39`	`* @param num`
`40`		`- * @return`
	`40`	`+ * @return the observable sequence starting after a number of skipped values`
`41`	`41`	`*`
`42`	`42`	`* @see <a href="http://msdn.microsoft.com/en-us/library/hh229847(v=vs.103).aspx">Observable.Skip(TSource) Method</a>`
`43`	`43`	`*/`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public final class OperationSynchronize<T> {`
`52`	`52`	`*`
`53`	`53`	`* @param observable`
`54`	`54`	`* @param <T>`
`55`		`- * @return`
	`55`	`+ * @return the wrapped synchronized observable sequence`
`56`	`56`	`*/`
`57`	`57`	`public static <T> Func1<Observer<T>, Subscription> synchronize(Observable<T> observable) {`
`58`	`58`	`return new Synchronize<T>(observable);`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public final class OperationTake {`
`42`	`42`	`*`
`43`	`43`	`* @param items`
`44`	`44`	`* @param num`
`45`		`- * @return`
	`45`	`+ * @return the specified number of contiguous values from the start of the given observable sequence`
`46`	`46`	`*/`
`47`	`47`	`public static <T> Func1<Observer<T>, Subscription> take(final Observable<T> items, final int num) {`
`48`	`48`	`// wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.`