HADOOP-15852. Refactor QuotaUsage. Contributed by David Mollitor.

Signed-off-by: Wei-Chiu Chuang <weichiu@apache.org>

hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/QuotaUsage.java

@@ -40,14 +40,13 @@ public class QuotaUsage {
   /** Builder class for QuotaUsage. */
   public static class Builder {
     public Builder() {
-      this.quota = -1;
-      this.spaceQuota = -1;
+      this.quota = -1L;
+      this.spaceQuota = -1L;
 
       typeConsumed = new long[StorageType.values().length];
       typeQuota = new long[StorageType.values().length];
-      for (int i = 0; i < typeQuota.length; i++) {
-        typeQuota[i] = -1;
-      }
+
+      Arrays.fill(typeQuota, -1L);
     }
 
     public Builder fileAndDirectoryCount(long count) {
@@ -71,9 +70,8 @@ public Builder spaceQuota(long spaceQuota) {
     }
 
     public Builder typeConsumed(long[] typeConsumed) {
-      for (int i = 0; i < typeConsumed.length; i++) {
-        this.typeConsumed[i] = typeConsumed[i];
-      }
+      System.arraycopy(typeConsumed, 0, this.typeConsumed, 0,
+          typeConsumed.length);
       return this;
     }
 
@@ -88,9 +86,7 @@ public Builder typeConsumed(StorageType type, long consumed) {
     }
 
     public Builder typeQuota(long[] typeQuota) {
-      for (int i = 0; i < typeQuota.length; i++) {
-        this.typeQuota[i] = typeQuota[i];
-      }
+      System.arraycopy(typeQuota, 0, this.typeQuota, 0, typeQuota.length);
       return this;
     }
 
@@ -153,78 +149,80 @@ public long getSpaceQuota() {
 
   /** Return storage type quota. */
   public long getTypeQuota(StorageType type) {
-    return (typeQuota != null) ? typeQuota[type.ordinal()] : -1;
+    return (typeQuota != null) ? typeQuota[type.ordinal()] : -1L;
   }
 
   /** Return storage type consumed. */
   public long getTypeConsumed(StorageType type) {
-    return (typeConsumed != null) ? typeConsumed[type.ordinal()] : 0;
-  }
-
-  /** Return storage type quota. */
-  private long[] getTypesQuota() {
-    return typeQuota;
-  }
-
-  /** Return storage type quota. */
-  private long[] getTypesConsumed() {
-    return typeConsumed;
+    return (typeConsumed != null) ? typeConsumed[type.ordinal()] : 0L;
   }
 
   /** Return true if any storage type quota has been set. */
   public boolean isTypeQuotaSet() {
-    if (typeQuota == null) {
-      return false;
-    }
+    if (typeQuota != null) {
       for (StorageType t : StorageType.getTypesSupportingQuota()) {
-      if (typeQuota[t.ordinal()] > 0) {
+        if (typeQuota[t.ordinal()] > 0L) {
           return true;
         }
       }
+    }
     return false;
   }
 
   /** Return true if any storage type consumption information is available. */
   public boolean isTypeConsumedAvailable() {
-    if (typeConsumed == null) {
-      return false;
-    }
+    if (typeConsumed != null) {
       for (StorageType t : StorageType.getTypesSupportingQuota()) {
-      if (typeConsumed[t.ordinal()] > 0) {
+        if (typeConsumed[t.ordinal()] > 0L) {
           return true;
         }
       }
-    return false;
     }
-
-  @Override
-  public boolean equals(Object to) {
-    return (this == to || (to instanceof QuotaUsage &&
-        getFileAndDirectoryCount() ==
-        ((QuotaUsage) to).getFileAndDirectoryCount() &&
-        getQuota() == ((QuotaUsage) to).getQuota() &&
-        getSpaceConsumed() == ((QuotaUsage) to).getSpaceConsumed() &&
-        getSpaceQuota() == ((QuotaUsage) to).getSpaceQuota() &&
-        Arrays.equals(getTypesQuota(), ((QuotaUsage) to).getTypesQuota()) &&
-        Arrays.equals(getTypesConsumed(),
-        ((QuotaUsage) to).getTypesConsumed())));
+    return false;
   }
 
   @Override
   public int hashCode() {
-    long result = (getFileAndDirectoryCount() ^ getQuota() ^
-        getSpaceConsumed() ^ getSpaceQuota());
-    if (getTypesQuota() != null) {
-      for (long quota : getTypesQuota()) {
-        result ^= quota;
+    final int prime = 31;
+    int result = 1;
+    result = prime * result
+        + (int) (fileAndDirectoryCount ^ (fileAndDirectoryCount >>> 32));
+    result = prime * result + (int) (quota ^ (quota >>> 32));
+    result = prime * result + (int) (spaceConsumed ^ (spaceConsumed >>> 32));
+    result = prime * result + (int) (spaceQuota ^ (spaceQuota >>> 32));
+    result = prime * result + Arrays.hashCode(typeConsumed);
+    result = prime * result + Arrays.hashCode(typeQuota);
+    return result;
   }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
     }
-    if (getTypesConsumed() != null) {
-      for (long consumed : getTypesConsumed()) {
-        result ^= consumed;
+    if (!(obj instanceof QuotaUsage)) {
+      return false;
     }
+    QuotaUsage other = (QuotaUsage) obj;
+    if (fileAndDirectoryCount != other.fileAndDirectoryCount) {
+      return false;
     }
-    return (int)result;
+    if (quota != other.quota) {
+      return false;
+    }
+    if (spaceConsumed != other.spaceConsumed) {
+      return false;
+    }
+    if (spaceQuota != other.spaceQuota) {
+      return false;
+    }
+    if (!Arrays.equals(typeConsumed, other.typeConsumed)) {
+      return false;
+    }
+    if (!Arrays.equals(typeQuota, other.typeQuota)) {
+      return false;
+    }
+    return true;
   }
 
   /**
@@ -292,11 +290,11 @@ protected String getQuotaUsage(boolean hOption) {
     String spaceQuotaStr = QUOTA_NONE;
     String spaceQuotaRem = QUOTA_INF;
 
-    if (quota > 0) {
+    if (quota > 0L) {
       quotaStr = formatSize(quota, hOption);
       quotaRem = formatSize(quota-fileAndDirectoryCount, hOption);
     }
-    if (spaceQuota >= 0) {
+    if (spaceQuota >= 0L) {
       spaceQuotaStr = formatSize(spaceQuota, hOption);
       spaceQuotaRem = formatSize(spaceQuota - spaceConsumed, hOption);
     }
@@ -307,20 +305,20 @@ protected String getQuotaUsage(boolean hOption) {
 
   protected String getTypesQuotaUsage(boolean hOption,
       List<StorageType> types) {
-    StringBuffer content = new StringBuffer();
+    StringBuilder content = new StringBuilder();
     for (StorageType st : types) {
       long typeQuota = getTypeQuota(st);
       long typeConsumed = getTypeConsumed(st);
       String quotaStr = QUOTA_NONE;
       String quotaRem = QUOTA_INF;
 
-      if (typeQuota >= 0) {
+      if (typeQuota >= 0L) {
         quotaStr = formatSize(typeQuota, hOption);
         quotaRem = formatSize(typeQuota - typeConsumed, hOption);
       }
 
-      content.append(String.format(STORAGE_TYPE_SUMMARY_FORMAT,
-          quotaStr, quotaRem));
+      content.append(
+          String.format(STORAGE_TYPE_SUMMARY_FORMAT, quotaStr, quotaRem));
     }
     return content.toString();
   }
@@ -332,7 +330,7 @@ protected String getTypesQuotaUsage(boolean hOption,
    * @return storage header string
    */
   public static String getStorageTypeHeader(List<StorageType> storageTypes) {
-    StringBuffer header = new StringBuffer();
+    StringBuilder header = new StringBuilder();
 
     for (StorageType st : storageTypes) {
       /* the field length is 13/17 for quota and remain quota