Fix all javadoc warnings (#410)

Author: vancexu

src/main/java/com/uber/cadence/client/ActivityWorkerShutdownException.java

@@ -18,12 +18,12 @@
 package com.uber.cadence.client;
 
 import com.uber.cadence.activity.ActivityTask;
-import com.uber.cadence.worker.Worker;
 import java.util.concurrent.TimeUnit;
 
 /**
- * Indicates that {@link Worker.Factory#shutdown()} or {@link Worker.Factory#shutdownNow()} was
- * called. It is OK to ignore the exception to let activity to complete. It assumes that {@link
+ * Indicates that {@link com.uber.cadence.worker.Worker.Factory#shutdown()} or {@link
+ * com.uber.cadence.worker.Worker.Factory#shutdownNow()} was called. It is OK to ignore the
+ * exception to let activity to complete. It assumes that {@link
  * com.uber.cadence.worker.Worker.Factory#awaitTermination(long, TimeUnit)} is called with a timeout
  * larger than the activity execution time.
  */

src/main/java/com/uber/cadence/converter/JsonDataConverter.java

@@ -36,7 +36,7 @@
 
 /**
  * Implements conversion through GSON JSON processor. To extend use {@link
- * JsonDataConverter(Function)} constructor. Thrift structures are converted using {@link
+ * #JsonDataConverter(Function)} constructor. Thrift structures are converted using {@link
  * TJSONProtocol}. When using thrift only one argument of a method is expected.
  *
  * @author fateev

src/main/java/com/uber/cadence/internal/common/WorkflowExecutionUtils.java

@@ -643,7 +643,7 @@ private void getNextPage() {
    *
    * @param showWorkflowTasks when set to false workflow task events (decider events) are not
    *     included
-   * @history Workflow instance history
+   * @param history Workflow instance history
    */
   public static String prettyPrintHistory(History history, boolean showWorkflowTasks) {
     return prettyPrintHistory(history.getEvents().iterator(), showWorkflowTasks);

src/main/java/com/uber/cadence/testing/TestWorkflowEnvironment.java

@@ -169,7 +169,7 @@ Worker newWorker(
    */
   String getDiagnostics();
 
-  /** Calls {@link #shutdownNow()} and {@link#awaitTermination(long, TimeUnit)}. */
+  /** Calls {@link #shutdownNow()} and {@link #awaitTermination(long, TimeUnit)}. */
   void close();
 
   Worker.Factory getWorkerFactory();

src/main/java/com/uber/cadence/workflow/CancellationScope.java

@@ -50,7 +50,7 @@ public interface CancellationScope extends Runnable {
   /**
    * Is scope was asked to cancel through {@link #cancel()} or by a parent scope.
    *
-   * @return
+   * @return whether request is cancelled or not.
    */
   boolean isCancelRequested();
 

src/main/java/com/uber/cadence/workflow/CompletablePromise.java

@@ -56,7 +56,7 @@ public interface CompletablePromise<V> extends Promise<V> {
    * </code></pre>
    *
    * @param source promise that is being watched.
-   * @return
+   * @return false if source already completed, otherwise return true or null
    */
   boolean completeFrom(Promise<V> source);
 }

src/main/java/com/uber/cadence/workflow/Promise.java

@@ -18,7 +18,6 @@
 package com.uber.cadence.workflow;
 
 import com.uber.cadence.internal.sync.WorkflowInternal;
-import com.uber.cadence.workflow.Functions.Func2;
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
@@ -40,8 +39,8 @@
  *   <li>Promise doesn't directly supports cancellation. Use {@link CancellationScope} to cancel and
  *       handle cancellations. The pattern is that a cancelled operation completes its Promise with
  *       {@link java.util.concurrent.CancellationException} when cancelled.
- *   <li>{@link #handle(Func2)} and similar callback operations do not allow blocking calls inside
- *       functions
+ *   <li>{@link #handle(Functions.Func2)} and similar callback operations do not allow blocking
+ *       calls inside functions
  * </ul>
  */
 public interface Promise<V> {

src/main/java/com/uber/cadence/workflow/Saga.java

@@ -267,7 +267,6 @@ public <A1, A2> void addCompensation(Functions.Func2<A1, A2, ?> operation, A1 ar
    * Add compensation operation for saga.
    *
    * @param operation to be executed during compensation.
-   * @param operation to be executed during compensation.
    * @param arg1 first operation function parameter
    * @param arg2 second operation function parameter
    * @param arg3 third operation function parameter
@@ -281,7 +280,6 @@ public <A1, A2, A3> void addCompensation(
    * Add compensation operation for saga.
    *
    * @param operation to be executed during compensation.
-   * @param operation to be executed during compensation.
    * @param arg1 first operation function parameter
    * @param arg2 second operation function parameter
    * @param arg3 third operation function parameter
@@ -296,7 +294,6 @@ public <A1, A2, A3, A4> void addCompensation(
    * Add compensation operation for saga.
    *
    * @param operation to be executed during compensation.
-   * @param operation to be executed during compensation.
    * @param arg1 first operation function parameter
    * @param arg2 second operation function parameter
    * @param arg3 third operation function parameter

src/main/java/com/uber/cadence/workflow/Workflow.java

@@ -24,9 +24,6 @@
 import com.uber.cadence.internal.sync.WorkflowInternal;
 import com.uber.cadence.worker.WorkerOptions;
 import com.uber.cadence.workflow.Functions.Func;
-import com.uber.cadence.workflow.Functions.Func1;
-import com.uber.cadence.workflow.Functions.Func2;
-import com.uber.cadence.workflow.Functions.Proc;
 import com.uber.m3.tally.Scope;
 import java.lang.reflect.Type;
 import java.time.Duration;
@@ -156,18 +153,18 @@
  * methods allow you to invoke any activity asynchronously. The call returns a {@link Promise}
  * result immediately. {@link Promise} is similar to both {@link java.util.concurrent.Future} and
  * {@link java.util.concurrent.CompletionStage}. The {@link Promise#get()} blocks until a result is
- * available. It also exposes the {@link Promise#thenApply(Func1)} and {@link Promise#handle(Func2)}
- * methods. See the {@link Promise} documentation for technical details about differences with
- * {@link java.util.concurrent.Future}.
+ * available. It also exposes the {@link Promise#thenApply(Functions.Func1)} and {@link
+ * Promise#handle(Functions.Func2)} methods. See the {@link Promise} documentation for technical
+ * details about differences with {@link java.util.concurrent.Future}.
  *
  * <p>To convert a synchronous call
  *
  * <pre><code>
  * String localName = activities.download(sourceBucket, sourceFile);
  * </code></pre>
  *
- * to asynchronous style, the method reference is passed to {@link Async#function(Func)} or {@link
- * Async#procedure(Proc)} followed by activity arguments:
+ * to asynchronous style, the method reference is passed to {@link Async#function(Functions.Func)}
+ * or {@link Async#procedure(Functions.Proc)} followed by activity arguments:
  *
  * <pre><code>
  * Promise<String> localNamePromise = Async.function(activities::download, sourceBucket, sourceFile);
@@ -243,13 +240,14 @@
  *
  * <p>The first call to the child workflow stub must always be to a method annotated with
  * {@literal @}{@link WorkflowMethod}. Similarly to activities, a call can be synchronous or
- * asynchronous using {@link Async#function(Func)} or {@link Async#procedure(Proc)}. The synchronous
- * call blocks until a child workflow completes. The asynchronous call returns a {@link Promise}
- * that can be used to wait for the completion. After an async call returns the stub, it can be used
- * to send signals to the child by calling methods annotated with {@literal @}{@link SignalMethod}.
- * Querying a child workflow by calling methods annotated with {@literal @}{@link QueryMethod} from
- * within workflow code is not supported. However, queries can be done from activities using the
- * {@link com.uber.cadence.client.WorkflowClient} provided stub.
+ * asynchronous using {@link Async#function(Functions.Func)} or {@link
+ * Async#procedure(Functions.Proc)}. The synchronous call blocks until a child workflow completes.
+ * The asynchronous call returns a {@link Promise} that can be used to wait for the completion.
+ * After an async call returns the stub, it can be used to send signals to the child by calling
+ * methods annotated with {@literal @}{@link SignalMethod}. Querying a child workflow by calling
+ * methods annotated with {@literal @}{@link QueryMethod} from within workflow code is not
+ * supported. However, queries can be done from activities using the {@link
+ * com.uber.cadence.client.WorkflowClient} provided stub.
  *
  * <pre><code>
  * public interface GreetingChild {
@@ -338,8 +336,8 @@
  *       for this.
  *   <li>Only use {@link #currentTimeMillis()} to get the current time inside a workflow.
  *   <li>Do not use native Java {@link Thread} or any other multi-threaded classes like {@link
- *       java.util.concurrent.ThreadPoolExecutor}. Use {@link Async#function(Func)} or {@link
- *       Async#procedure(Proc)} to execute code asynchronously.
+ *       java.util.concurrent.ThreadPoolExecutor}. Use {@link Async#function(Functions.Func)} or
+ *       {@link Async#procedure(Functions.Proc)} to execute code asynchronously.
  *   <li>Don't use any synchronization, locks, and other standard Java blocking concurrency-related
  *       classes besides those provided by the Workflow class. There is no need in explicit
  *       synchronization because multi-threaded code inside a workflow is executed one thread at a
@@ -904,7 +902,7 @@ public static boolean isReplaying() {
    * @param resultClass type of the side effect
    * @param func function that returns side effect value
    * @return value of the side effect
-   * @see #mutableSideEffect(String, Class, BiPredicate, Func)
+   * @see #mutableSideEffect(String, Class, BiPredicate, Functions.Func)
    */
   public static <R> R sideEffect(Class<R> resultClass, Func<R> func) {
     return WorkflowInternal.sideEffect(resultClass, resultClass, func);
@@ -959,21 +957,22 @@ public static <R> R sideEffect(Class<R> resultClass, Func<R> func) {
    * @param resultType type of the side effect. Differs from resultClass for generic types.
    * @param func function that returns side effect value
    * @return value of the side effect
-   * @see #mutableSideEffect(String, Class, BiPredicate, Func)
+   * @see #mutableSideEffect(String, Class, BiPredicate, Functions.Func)
    */
   public static <R> R sideEffect(Class<R> resultClass, Type resultType, Func<R> func) {
     return WorkflowInternal.sideEffect(resultClass, resultType, func);
   }
 
   /**
-   * {@code mutableSideEffect} is similar to {@link #sideEffect(Class, Func)} in allowing calls of
-   * non-deterministic functions from workflow code.
+   * {@code mutableSideEffect} is similar to {@link #sideEffect(Class, Functions.Func)} in allowing
+   * calls of non-deterministic functions from workflow code.
    *
-   * <p>The difference between {@code mutableSideEffect} and {@link #sideEffect(Class, Func)} is
-   * that every new {@code sideEffect} call in non-replay mode results in a new marker event
-   * recorded into the history. However, {@code mutableSideEffect} only records a new marker if a
-   * value has changed. During the replay, {@code mutableSideEffect} will not execute the function
-   * again, but it will return the exact same value as it was returning during the non-replay run.
+   * <p>The difference between {@code mutableSideEffect} and {@link #sideEffect(Class,
+   * Functions.Func)} is that every new {@code sideEffect} call in non-replay mode results in a new
+   * marker event recorded into the history. However, {@code mutableSideEffect} only records a new
+   * marker if a value has changed. During the replay, {@code mutableSideEffect} will not execute
+   * the function again, but it will return the exact same value as it was returning during the
+   * non-replay run.
    *
    * <p>One good use case of {@code mutableSideEffect} is to access a dynamically changing config
    * without breaking determinism. Even if called very frequently the config value is recorded only
@@ -991,22 +990,23 @@ public static <R> R sideEffect(Class<R> resultClass, Type resultType, Func<R> fu
    *     for the first value.
    * @param resultClass class of the side effect
    * @param func function that produces a value. This function can contain non deterministic code.
-   * @see #sideEffect(Class, Func)
+   * @see #sideEffect(Class, Functions.Func)
    */
   public static <R> R mutableSideEffect(
       String id, Class<R> resultClass, BiPredicate<R, R> updated, Func<R> func) {
     return WorkflowInternal.mutableSideEffect(id, resultClass, resultClass, updated, func);
   }
 
   /**
-   * {@code mutableSideEffect} is similar to {@link #sideEffect(Class, Func)} in allowing calls of
-   * non-deterministic functions from workflow code.
+   * {@code mutableSideEffect} is similar to {@link #sideEffect(Class, Functions.Func)} in allowing
+   * calls of non-deterministic functions from workflow code.
    *
-   * <p>The difference between {@code mutableSideEffect} and {@link #sideEffect(Class, Func)} is
-   * that every new {@code sideEffect} call in non-replay mode results in a new marker event
-   * recorded into the history. However, {@code mutableSideEffect} only records a new marker if a
-   * value has changed. During the replay, {@code mutableSideEffect} will not execute the function
-   * again, but it will return the exact same value as it was returning during the non-replay run.
+   * <p>The difference between {@code mutableSideEffect} and {@link #sideEffect(Class,
+   * Functions.Func)} is that every new {@code sideEffect} call in non-replay mode results in a new
+   * marker event recorded into the history. However, {@code mutableSideEffect} only records a new
+   * marker if a value has changed. During the replay, {@code mutableSideEffect} will not execute
+   * the function again, but it will return the exact same value as it was returning during the
+   * non-replay run.
    *
    * <p>One good use case of {@code mutableSideEffect} is to access a dynamically changing config
    * without breaking determinism. Even if called very frequently the config value is recorded only
@@ -1025,7 +1025,7 @@ public static <R> R mutableSideEffect(
    * @param resultClass class of the side effect
    * @param resultType type of the side effect. Differs from resultClass for generic types.
    * @param func function that produces a value. This function can contain non deterministic code.
-   * @see #sideEffect(Class, Func)
+   * @see #sideEffect(Class, Functions.Func)
    */
   public static <R> R mutableSideEffect(
       String id, Class<R> resultClass, Type resultType, BiPredicate<R, R> updated, Func<R> func) {
@@ -1134,8 +1134,8 @@ public static Scope getMetricsScope() {
   }
 
   /**
-   * Get logger to use inside workflow. Logs in replay mode are omitted unless {@param
-   * enableLoggingInReplay} is set to true in {@link WorkerOptions} when a worker starts up.
+   * Get logger to use inside workflow. Logs in replay mode are omitted unless enableLoggingInReplay
+   * is set to true in {@link WorkerOptions} when a worker starts up.
    *
    * @param clazz class name to appear in logging.
    * @return logger to use in workflow logic.
@@ -1145,8 +1145,8 @@ public static Logger getLogger(Class<?> clazz) {
   }
 
   /**
-   * Get logger to use inside workflow. Logs in replay mode are omitted unless {@param
-   * enableLoggingInReplay} is set to true in {@link WorkerOptions} when a worker starts up.
+   * Get logger to use inside workflow. Logs in replay mode are omitted unless enableLoggingInReplay
+   * is set to true in {@link WorkerOptions} when a worker starts up.
    *
    * @param name name to appear in logging.
    * @return logger to use in workflow logic.