A handful more javadoc changes (misnamed @params and such)

Author: DavidMGross

src/main/java/rx/Single.java

@@ -73,12 +73,12 @@ public class Single<T> {
     /**
      * Creates a Single with a Function to execute when it is subscribed to (executed).
      * <p>
-     * <em>Note:</em> Use {@link #create(OnExecute)} to create a Single, instead of this constructor,
+     * <em>Note:</em> Use {@link #create(OnSubscribe)} to create a Single, instead of this constructor,
      * unless you specifically have a need for inheritance.
      * 
      * @param f
-     *            {@link OnExecute} to be executed when {@link #execute(SingleSubscriber)} or
-     *            {@link #subscribe(Subscriber)} is called
+     *            {@code OnExecute} to be executed when {@code execute(SingleSubscriber)} or
+     *            {@code subscribe(Subscriber)} is called
      */
     protected Single(final OnSubscribe<T> f) {
         // bridge between OnSubscribe (which all Operators and Observables use) and OnExecute (for Single)
@@ -1294,11 +1294,11 @@ public final Single<T> observeOn(Scheduler scheduler) {
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.onErrorReturn.png" alt="">
      * <p>
      * By default, when a Single encounters an error that prevents it from emitting the expected item to its
-     * subscriber, the Single invokes its subscriber's {@link SingleSubscriber#onError} method, and then quits
+     * subscriber, the Single invokes its subscriber's {@link Subscriber#onError} method, and then quits
      * without invoking any more of its subscriber's methods. The {@code onErrorReturn} method changes this
      * behavior. If you pass a function ({@code resumeFunction}) to a Single's {@code onErrorReturn} method, if
      * the original Single encounters an error, instead of invoking its subscriber's
-     * {@link SingleSubsriber#onError} method, it will instead emit the return value of {@code resumeFunction}.
+     * {@link Subscriber#onError} method, it will instead emit the return value of {@code resumeFunction}.
      * <p>
      * You can use this to prevent errors from propagating or to supply fallback data should errors be
      * encountered.
@@ -1357,7 +1357,7 @@ public final void onNext(T args) {
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
-     * @param onNext
+     * @param onSuccess
      *            the {@code Action1<T>} you have designed to accept the emission from the Single
      * @return a {@link Subscription} reference can request the {@link Single} stop work.
      * @throws IllegalArgumentException
@@ -1399,7 +1399,7 @@ public final void onNext(T args) {
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
-     * @param onNext
+     * @param onSuccess
      *            the {@code Action1<T>} you have designed to accept the emission from the Single
      * @param onError
      *            the {@code Action1<Throwable>} you have designed to accept any error notification from the
@@ -1593,17 +1593,17 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
-     * @param subscriber
-     *            the {@link Subscriber} that will handle the emission or notification from the Single
+     * @param te
+     *            the {@link SingleSubscriber} that will handle the emission or notification from the Single
      * @return a {@link Subscription} reference can request the {@link Single} stop work.
      * @throws IllegalStateException
      *             if {@code subscribe} is unable to obtain an {@code OnSubscribe<>} function
      * @throws IllegalArgumentException
-     *             if the {@link Subscriber} provided as the argument to {@code subscribe} is {@code null}
+     *             if the {@link SingleSubscriber} provided as the argument to {@code subscribe} is {@code null}
      * @throws OnErrorNotImplementedException
-     *             if the {@link Subscriber}'s {@code onError} method is null
+     *             if the {@link SingleSubscriber}'s {@code onError} method is null
      * @throws RuntimeException
-     *             if the {@link Subscriber}'s {@code onError} method itself threw a {@code Throwable}
+     *             if the {@link SingleSubscriber}'s {@code onError} method itself threw a {@code Throwable}
      * @see <a href="http://reactivex.io/documentation/operators/subscribe.html">ReactiveX operators documentation: Subscribe</a>
      */
     public final Subscription subscribe(final SingleSubscriber<? super T> te) {

src/main/java/rx/SingleSubscriber.java

@@ -21,10 +21,10 @@
 /**
  * Provides a mechanism for receiving push-based notifications.
  * <p>
- * After an SingleSubscriber calls an {@link Single}'s {@link Single#subscribe subscribe} method, the
- * {@code Single} calls the SingleSubscriber's {@link #onSuccess} and {@link #onError} methods to provide notifications. 
- * A well-behaved {@code Single} will call an SingleSubscriber's {@link #onSuccess} method exactly once or 
- * the SingleSubscriber's {@link #onError} method exactly once.
+ * After a SingleSubscriber calls a {@link Single}'s {@link Single#subscribe subscribe} method, the
+ * {@code Single} calls the SingleSubscriber's {@link #onSuccess} and {@link #onError} methods to provide
+ * notifications. A well-behaved {@code Single} will call a SingleSubscriber's {@link #onSuccess} method exactly
+ * once or the SingleSubscriber's {@link #onError} method exactly once.
  * 
  * @see <a href="http://reactivex.io/documentation/observable.html">ReactiveX documentation: Observable</a>
  * @param <T>
@@ -36,9 +36,13 @@ public abstract class SingleSubscriber<T> implements Subscription {
     private final SubscriptionList cs = new SubscriptionList();
 
     /**
-     * Notifies the SingleSubscriber with a single item and that the {@link Single} has finished sending push-based notifications.
+     * Notifies the SingleSubscriber with a single item and that the {@link Single} has finished sending
+     * push-based notifications.
      * <p>
      * The {@link Single} will not call this method if it calls {@link #onError}.
+     * 
+     * @param value
+     *          the item emitted by the Single
      */
     public abstract void onSuccess(T value);
 
@@ -47,7 +51,7 @@ public abstract class SingleSubscriber<T> implements Subscription {
      * <p>
      * If the {@link Single} calls this method, it will not thereafter call {@link #onSuccess}.
      * 
-     * @param e
+     * @param error
      *          the exception encountered by the Single
      */
     public abstract void onError(Throwable error);
@@ -78,4 +82,4 @@ public final void unsubscribe() {
     public final boolean isUnsubscribed() {
         return cs.isUnsubscribed();
     }
-}
+}