CLEANUP: Reformat code in v2 package

src/main/java/net/spy/memcached/v2/AbstractArcusResult.java

@@ -28,12 +28,12 @@
 
 public class AbstractArcusResult<T> implements ArcusResult<T> {
 
-  protected AtomicReference<T> value;
-
-  private final List<Exception> exceptions = new ArrayList<>();
+  private final AtomicReference<T> value;
+  private final List<Exception> exceptions;
 
   public AbstractArcusResult(AtomicReference<T> value) {
     this.value = value;
+    this.exceptions = new ArrayList<>();
   }
 
   @Override

src/main/java/net/spy/memcached/v2/ArcusMultiFuture.java

@@ -32,8 +32,6 @@
  * also completes exceptionally. If multiple futures completed exceptionally,
  * This future will throw CompositeException containing all exceptions.
  * And the combined result can be obtained.
- *
- * @param <T>
  */
 public final class ArcusMultiFuture<T> extends CompletableFuture<T> implements ArcusFuture<T> {
 

src/main/java/net/spy/memcached/v2/ArcusResult.java

@@ -23,6 +23,7 @@
 
 /**
  * Class to hold the result and errors occurred during Arcus operation.
+ *
  * @param <T> the type of the result
  */
 public interface ArcusResult<T> {

src/main/java/net/spy/memcached/v2/vo/BKey.java

@@ -7,6 +7,12 @@
 import net.spy.memcached.util.BTreeUtil;
 
 public final class BKey implements Comparable<BKey> {
+
+  public enum BKeyType {
+    BYTE_ARRAY,
+    LONG
+  }
+
   private final BKeyType type;
   private final Object data;
 
@@ -71,11 +77,6 @@ public static BKey of(BKeyObject bkeyObject) {
     }
   }
 
-  public enum BKeyType {
-    BYTE_ARRAY,
-    LONG;
-  }
-
   public Object getData() {
     if (type == BKeyType.BYTE_ARRAY) {
       byte[] bytes = (byte[]) data;

src/main/java/net/spy/memcached/v2/vo/GetArgs.java

@@ -7,6 +7,11 @@ public final class GetArgs {
   private final boolean withDelete;
   private final boolean dropIfEmpty;
 
+  private GetArgs(boolean withDelete, boolean dropIfEmpty) {
+    this.withDelete = withDelete;
+    this.dropIfEmpty = dropIfEmpty;
+  }
+
   public boolean isWithDelete() {
     return withDelete;
   }
@@ -15,11 +20,6 @@ public boolean isDropIfEmpty() {
     return dropIfEmpty;
   }
 
-  private GetArgs(boolean withDelete, boolean dropIfEmpty) {
-    this.withDelete = withDelete;
-    this.dropIfEmpty = dropIfEmpty;
-  }
-
   public static class Builder {
     private boolean withDelete = false;
     private boolean dropIfEmpty = false;

src/main/java/net/spy/memcached/v2/vo/SMGetElements.java

@@ -34,7 +34,7 @@ public static <T> SMGetElements<T> mergeSMGetElements(List<SMGetElements<T>> smG
 
     // 1) Collect elements considering unique, count option.
     mergeSMGetElements(smGetElementsList, elements, missedKeys, trimmedKeys,
-            ascending, unique, count);
+        ascending, unique, count);
 
     // 2) Sort missed keys, and trimmed keys
     Collections.sort(missedKeys);
@@ -53,15 +53,15 @@ public static <T> SMGetElements<T> mergeSMGetElements(List<SMGetElements<T>> smG
   }
 
   private static <T> void mergeSMGetElements(
-          List<SMGetElements<T>> smGetElementsList,
-          List<Element<T>> elements,
-          List<MissedKey> missedKeys,
-          List<TrimmedKey> trimmedKeys,
-          boolean ascending, boolean unique, int count) {
+      List<SMGetElements<T>> smGetElementsList,
+      List<Element<T>> elements,
+      List<MissedKey> missedKeys,
+      List<TrimmedKey> trimmedKeys,
+      boolean ascending, boolean unique, int count) {
     // 1) Create Priority queue to hold the current smallest/largest element from each list
     Comparator<ElementWithIndex<T>> comparator = ascending
-            ? Comparator.naturalOrder()
-            : Comparator.reverseOrder();
+        ? Comparator.naturalOrder()
+        : Comparator.reverseOrder();
     PriorityQueue<ElementWithIndex<T>> pq = new PriorityQueue<>(comparator);
 
     // 2) Initialize the priority queue with the first element from each list
@@ -93,7 +93,7 @@ private static <T> void mergeSMGetElements(
       List<Element<T>> sourceList = smGetElementsList.get(current.listIndex).getElements();
       if (nextIndex < sourceList.size()) {
         pq.offer(new ElementWithIndex<>(sourceList.get(nextIndex),
-                current.listIndex, nextIndex));
+            current.listIndex, nextIndex));
       }
     }
   }