Added Google java formatter (#120)

* Added google-java-format to build.gradle

* Reformatted by google java formatter

Author: mfateev

build.gradle

@@ -6,6 +6,7 @@ buildscript {
 
 plugins {
     id 'net.minecrell.licenser' version '0.3'
+    id "com.github.sherter.google-java-format" version "0.6"
 }
 
 repositories {
@@ -19,6 +20,13 @@ apply plugin: 'java'
 apply plugin: 'maven'
 apply plugin: "org.jruyi.thrift"
 apply plugin: 'maven-publish'
+apply plugin: 'com.github.sherter.google-java-format'
+
+googleJavaFormat {
+    toolVersion '1.3'
+    include '**/*.java'
+    exclude '**/generated-sources/*'
+}
 
 group = 'com.uber'
 version = '0.2.0-SNAPSHOT'

src/main/java/com/uber/cadence/activity/Activity.java

@@ -22,108 +22,103 @@
 import com.uber.cadence.internal.sync.WorkflowInternal;
 import com.uber.cadence.workflow.ActivityException;
 import com.uber.cadence.workflow.ActivityTimeoutException;
-
 import java.util.concurrent.CancellationException;
 
 /**
- * Use this method from within activity implementation to get information about activity task
- * and heartbeat.
+ * Use this method from within activity implementation to get information about activity task and
+ * heartbeat.
  */
 public final class Activity {
 
-    /**
-     * If this method is called during an activity execution then activity is not going to complete
-     * when its method returns. It is expected to be completed asynchronously using
-     * {@link com.uber.cadence.client.ActivityCompletionClient}.
-     */
-    public static void doNotCompleteOnReturn() {
-        ActivityInternal.doNotCompleteOnReturn();
-    }
+  /**
+   * If this method is called during an activity execution then activity is not going to complete
+   * when its method returns. It is expected to be completed asynchronously using {@link
+   * com.uber.cadence.client.ActivityCompletionClient}.
+   */
+  public static void doNotCompleteOnReturn() {
+    ActivityInternal.doNotCompleteOnReturn();
+  }
 
-    /**
-     * @return task token that is required to report task completion when
-     * manual activity completion is used.
-     */
-    public static byte[] getTaskToken() {
-        return ActivityInternal.getTask().getTaskToken();
-    }
+  /**
+   * @return task token that is required to report task completion when manual activity completion
+   *     is used.
+   */
+  public static byte[] getTaskToken() {
+    return ActivityInternal.getTask().getTaskToken();
+  }
 
-    /**
-     * @return workfow execution that requested the activity execution
-     */
-    public static com.uber.cadence.WorkflowExecution getWorkflowExecution() {
-        return ActivityInternal.getTask().getWorkflowExecution();
-    }
+  /** @return workfow execution that requested the activity execution */
+  public static com.uber.cadence.WorkflowExecution getWorkflowExecution() {
+    return ActivityInternal.getTask().getWorkflowExecution();
+  }
 
-    /**
-     * @return task that caused activity execution
-     */
-    public static ActivityTask getTask() {
-        return ActivityInternal.getTask();
-    }
+  /** @return task that caused activity execution */
+  public static ActivityTask getTask() {
+    return ActivityInternal.getTask();
+  }
 
-    /**
-     * Use to notify Cadence service that activity execution is alive.
-     *
-     * @param details In case of activity timeout can be accessed through
-     *                {@link ActivityTimeoutException#getDetails(Class)} method.
-     * @throws CancellationException Indicates that activity cancellation was requested by the
-     *                               workflow.Should be rethrown from activity implementation to
-     *                               indicate successful cancellation.
-     */
-    public static void heartbeat(Object details) throws CancellationException {
-        ActivityInternal.recordActivityHeartbeat(details);
-    }
+  /**
+   * Use to notify Cadence service that activity execution is alive.
+   *
+   * @param details In case of activity timeout can be accessed through {@link
+   *     ActivityTimeoutException#getDetails(Class)} method.
+   * @throws CancellationException Indicates that activity cancellation was requested by the
+   *     workflow.Should be rethrown from activity implementation to indicate successful
+   *     cancellation.
+   */
+  public static void heartbeat(Object details) throws CancellationException {
+    ActivityInternal.recordActivityHeartbeat(details);
+  }
 
-    /**
-     * @return an instance of the Simple Workflow Java client that is the same
-     * used by the invoked activity worker. It can be useful if activity wants to use WorkflowClient for
-     * some operations like sending signal to its parent workflow.
-     * @TODO getWorkflowClient method to hide the service.
-     */
-    public static WorkflowService.Iface getService() {
-        return ActivityInternal.getService();
-    }
+  /**
+   * @return an instance of the Simple Workflow Java client that is the same used by the invoked
+   *     activity worker. It can be useful if activity wants to use WorkflowClient for some
+   *     operations like sending signal to its parent workflow. @TODO getWorkflowClient method to
+   *     hide the service.
+   */
+  public static WorkflowService.Iface getService() {
+    return ActivityInternal.getService();
+  }
 
-    public static String getDomain() {
-        return ActivityInternal.getDomain();
-    }
+  public static String getDomain() {
+    return ActivityInternal.getDomain();
+  }
 
-    /**
-     * If there is a need to return a checked exception from an activity
-     * do not add the exception to a method signature but rethrow it using this method.
-     * The library code will unwrap it automatically when propagating exception to the caller.
-     * There is no need to wrap unchecked exceptions, but it is safe to call this method on them.
-     * <p>
-     * The reason for such design is that returning originally thrown exception from a remote call
-     * (which child workflow and activity invocations are ) would not allow adding context information about
-     * a failure, like activity and child workflow id. So stubs always throw a subclass of
-     * {@link ActivityException} from calls to an activity and subclass of
-     * {@link com.uber.cadence.workflow.ChildWorkflowException} from calls to a child workflow.
-     * The original exception is attached as a cause to these wrapper exceptions. So as exceptions are always wrapped
-     * adding checked ones to method signature causes more pain than benefit.
-     * </p>
-     * Throws original exception if e is {@link RuntimeException} or {@link Error}.
-     * Never returns. But return type is not empty to be able to use it as:
-     * <pre>
-     * try {
-     *     return someCall();
-     * } catch (Exception e) {
-     *     throw CheckedExceptionWrapper.throwWrapped(e);
-     * }
-     * </pre>
-     * If throwWrapped returned void it wouldn't be possible to write <code>throw CheckedExceptionWrapper.throwWrapped</code>
-     * and compiler would complain about missing return.
-     *
-     * @return never returns as always throws.
-     */
-    public static RuntimeException wrap(Exception e) {
-        return WorkflowInternal.wrap(e);
-    }
+  /**
+   * If there is a need to return a checked exception from an activity do not add the exception to a
+   * method signature but rethrow it using this method. The library code will unwrap it
+   * automatically when propagating exception to the caller. There is no need to wrap unchecked
+   * exceptions, but it is safe to call this method on them.
+   *
+   * <p>The reason for such design is that returning originally thrown exception from a remote call
+   * (which child workflow and activity invocations are ) would not allow adding context information
+   * about a failure, like activity and child workflow id. So stubs always throw a subclass of
+   * {@link ActivityException} from calls to an activity and subclass of {@link
+   * com.uber.cadence.workflow.ChildWorkflowException} from calls to a child workflow. The original
+   * exception is attached as a cause to these wrapper exceptions. So as exceptions are always
+   * wrapped adding checked ones to method signature causes more pain than benefit.
+   *
+   * <p>Throws original exception if e is {@link RuntimeException} or {@link Error}. Never returns.
+   * But return type is not empty to be able to use it as:
+   *
+   * <pre>
+   * try {
+   *     return someCall();
+   * } catch (Exception e) {
+   *     throw CheckedExceptionWrapper.throwWrapped(e);
+   * }
+   * </pre>
+   *
+   * If throwWrapped returned void it wouldn't be possible to write <code>
+   * throw CheckedExceptionWrapper.throwWrapped</code> and compiler would complain about missing
+   * return.
+   *
+   * @return never returns as always throws.
+   */
+  public static RuntimeException wrap(Exception e) {
+    return WorkflowInternal.wrap(e);
+  }
 
-    /**
-     * Prohibit instantiation
-     */
-    private Activity() {
-    }
+  /** Prohibit instantiation */
+  private Activity() {}
 }

src/main/java/com/uber/cadence/activity/ActivityMethod.java

@@ -23,50 +23,47 @@
 import java.lang.annotation.Target;
 
 /**
- * Indicates that the method is an activity method.
- * This annotation applies only to activity interface methods.
- * Not required. Use it to override default activity type name or other options.
- * When both {@link ActivityOptions} and {@link ActivityMethod} have non default value
- * for some parameter the {@link ActivityOptions} one takes precedence.
+ * Indicates that the method is an activity method. This annotation applies only to activity
+ * interface methods. Not required. Use it to override default activity type name or other options.
+ * When both {@link ActivityOptions} and {@link ActivityMethod} have non default value for some
+ * parameter the {@link ActivityOptions} one takes precedence.
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 public @interface ActivityMethod {
 
-    /**
-     * Name of the workflow type. Default is {short class name}::{method name}
-     */
-    String name() default "";
+  /** Name of the workflow type. Default is {short class name}::{method name} */
+  String name() default "";
 
-    /**
-     * Overall timeout workflow is willing to wait for activity to complete.
-     * It includes time in a task list (use {@link #scheduleToStartTimeoutSeconds()} to limit it)
-     * plus activity execution time (use {@link #startToCloseTimeoutSeconds()} to limit it).
-     * Either this option or both schedule to start and start to close are required.
-     */
-    int scheduleToCloseTimeoutSeconds() default 0;
+  /**
+   * Overall timeout workflow is willing to wait for activity to complete. It includes time in a
+   * task list (use {@link #scheduleToStartTimeoutSeconds()} to limit it) plus activity execution
+   * time (use {@link #startToCloseTimeoutSeconds()} to limit it). Either this option or both
+   * schedule to start and start to close are required.
+   */
+  int scheduleToCloseTimeoutSeconds() default 0;
 
-    /**
-     * Time activity can stay in task list before it is picked up by a worker.
-     * If schedule to close is not provided then both this and start to close are required.
-     */
-    int scheduleToStartTimeoutSeconds() default 0;
+  /**
+   * Time activity can stay in task list before it is picked up by a worker. If schedule to close is
+   * not provided then both this and start to close are required.
+   */
+  int scheduleToStartTimeoutSeconds() default 0;
 
-    /**
-     * Maximum activity execution time after it was sent to a worker.
-     * If schedule to close is not provided then both this and schedule to start are required.
-     */
-    int startToCloseTimeoutSeconds() default 0;
+  /**
+   * Maximum activity execution time after it was sent to a worker. If schedule to close is not
+   * provided then both this and schedule to start are required.
+   */
+  int startToCloseTimeoutSeconds() default 0;
 
-    /**
-     * Heartbeat interval. Activity must heartbeat before this interval passes after a last heartbeat
-     * or activity start.
-     */
-    int heartbeatTimeoutSeconds() default 0;
+  /**
+   * Heartbeat interval. Activity must heartbeat before this interval passes after a last heartbeat
+   * or activity start.
+   */
+  int heartbeatTimeoutSeconds() default 0;
 
-    /**
-     * Task list to use when dispatching activity task to a worker. By default it is the same task list name
-     * the workflow was started with.
-     */
-    String taskList() default "";
+  /**
+   * Task list to use when dispatching activity task to a worker. By default it is the same task
+   * list name the workflow was started with.
+   */
+  String taskList() default "";
 }