You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by st...@apache.org on 2017/01/29 05:31:17 UTC

hbase git commit: HBASE-17563 Changed for-loops and switch-statements in RootDocProcessor and StabilityOptions

Repository: hbase
Updated Branches:
  refs/heads/master 3693d1306 -> 87e1ba9a1


HBASE-17563 Changed for-loops and switch-statements in RootDocProcessor and StabilityOptions

Signed-off-by: Michael Stack <st...@apache.org>


Project: http://git-wip-us.apache.org/repos/asf/hbase/repo
Commit: http://git-wip-us.apache.org/repos/asf/hbase/commit/87e1ba9a
Tree: http://git-wip-us.apache.org/repos/asf/hbase/tree/87e1ba9a
Diff: http://git-wip-us.apache.org/repos/asf/hbase/diff/87e1ba9a

Branch: refs/heads/master
Commit: 87e1ba9a1a67780a7bd1bfbad65d263f83a1fe14
Parents: 3693d13
Author: Jan Hentschel <ja...@ultratendency.com>
Authored: Fri Jan 27 23:20:09 2017 +0100
Committer: Michael Stack <st...@apache.org>
Committed: Sat Jan 28 21:30:39 2017 -0800

----------------------------------------------------------------------
 .../classification/tools/RootDocProcessor.java  | 67 ++++++++++----------
 .../classification/tools/StabilityOptions.java  | 33 ++++++----
 2 files changed, 55 insertions(+), 45 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/hbase/blob/87e1ba9a/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/RootDocProcessor.java
----------------------------------------------------------------------
diff --git a/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/RootDocProcessor.java b/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/RootDocProcessor.java
index 6cc7551..e9fd6f9 100644
--- a/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/RootDocProcessor.java
+++ b/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/RootDocProcessor.java
@@ -107,44 +107,47 @@ final class RootDocProcessor {
           return !exclude(doc) && doc.isIncluded();
         }
         if (target instanceof RootDoc) {
-          if (methodName.equals("classes")) {
-            return filter(((RootDoc) target).classes(), ClassDoc.class);
-          } else if (methodName.equals("specifiedClasses")) {
-            return filter(((RootDoc) target).specifiedClasses(), ClassDoc.class);
-          } else if (methodName.equals("specifiedPackages")) {
-            return filter(((RootDoc) target).specifiedPackages(), PackageDoc.class);
+          switch (methodName) {
+            case "classes":
+              return filter(((RootDoc) target).classes(), ClassDoc.class);
+            case "specifiedClasses":
+              return filter(((RootDoc) target).specifiedClasses(), ClassDoc.class);
+            case "specifiedPackages":
+              return filter(((RootDoc) target).specifiedPackages(), PackageDoc.class);
           }
         } else if (target instanceof ClassDoc) {
           if (isFiltered(args)) {
-            if (methodName.equals("methods")) {
-              return filter(((ClassDoc) target).methods(true), MethodDoc.class);
-            } else if (methodName.equals("fields")) {
-              return filter(((ClassDoc) target).fields(true), FieldDoc.class);
-            } else if (methodName.equals("innerClasses")) {
-              return filter(((ClassDoc) target).innerClasses(true), ClassDoc.class);
-            } else if (methodName.equals("constructors")) {
-              return filter(((ClassDoc) target).constructors(true), ConstructorDoc.class);
+            switch (methodName) {
+              case "methods":
+                return filter(((ClassDoc) target).methods(true), MethodDoc.class);
+              case "fields":
+                return filter(((ClassDoc) target).fields(true), FieldDoc.class);
+              case "innerClasses":
+                return filter(((ClassDoc) target).innerClasses(true), ClassDoc.class);
+              case "constructors":
+                return filter(((ClassDoc) target).constructors(true), ConstructorDoc.class);
             }
           }
         } else if (target instanceof PackageDoc) {
-          if (methodName.equals("allClasses")) {
-            if (isFiltered(args)) {
-              return filter(((PackageDoc) target).allClasses(true), ClassDoc.class);
-            } else {
-              return filter(((PackageDoc) target).allClasses(), ClassDoc.class);
-            }
-          } else if (methodName.equals("annotationTypes")) {
-            return filter(((PackageDoc) target).annotationTypes(), AnnotationTypeDoc.class);
-          } else if (methodName.equals("enums")) {
-            return filter(((PackageDoc) target).enums(), ClassDoc.class);
-          } else if (methodName.equals("errors")) {
-            return filter(((PackageDoc) target).errors(), ClassDoc.class);
-          } else if (methodName.equals("exceptions")) {
-            return filter(((PackageDoc) target).exceptions(), ClassDoc.class);
-          } else if (methodName.equals("interfaces")) {
-            return filter(((PackageDoc) target).interfaces(), ClassDoc.class);
-          } else if (methodName.equals("ordinaryClasses")) {
-            return filter(((PackageDoc) target).ordinaryClasses(), ClassDoc.class);
+          switch (methodName) {
+            case "allClasses":
+              if (isFiltered(args)) {
+                return filter(((PackageDoc) target).allClasses(true), ClassDoc.class);
+              } else {
+                return filter(((PackageDoc) target).allClasses(), ClassDoc.class);
+              }
+            case "annotationTypes":
+              return filter(((PackageDoc) target).annotationTypes(), AnnotationTypeDoc.class);
+            case "enums":
+              return filter(((PackageDoc) target).enums(), ClassDoc.class);
+            case "errors":
+              return filter(((PackageDoc) target).errors(), ClassDoc.class);
+            case "exceptions":
+              return filter(((PackageDoc) target).exceptions(), ClassDoc.class);
+            case "interfaces":
+              return filter(((PackageDoc) target).interfaces(), ClassDoc.class);
+            case "ordinaryClasses":
+              return filter(((PackageDoc) target).ordinaryClasses(), ClassDoc.class);
           }
         }
       }

http://git-wip-us.apache.org/repos/asf/hbase/blob/87e1ba9a/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/StabilityOptions.java
----------------------------------------------------------------------
diff --git a/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/StabilityOptions.java b/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/StabilityOptions.java
index 7454436..1c6b4f2 100644
--- a/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/StabilityOptions.java
+++ b/hbase-annotations/src/main/java/org/apache/hadoop/hbase/classification/tools/StabilityOptions.java
@@ -40,25 +40,32 @@ final class StabilityOptions {
   }
 
   public static void validOptions(String[][] options, DocErrorReporter reporter) {
-    for (int i = 0; i < options.length; i++) {
-      String opt = options[i][0].toLowerCase(Locale.ROOT);
-      if (opt.equals(UNSTABLE_OPTION)) {
-        RootDocProcessor.stability = UNSTABLE_OPTION;
-      } else if (opt.equals(EVOLVING_OPTION)) {
-        RootDocProcessor.stability = EVOLVING_OPTION;
-      } else if (opt.equals(STABLE_OPTION)) {
-        RootDocProcessor.stability = STABLE_OPTION;
+    for (String[] option : options) {
+      String opt = option[0].toLowerCase(Locale.ROOT);
+      switch (opt) {
+        case UNSTABLE_OPTION:
+          RootDocProcessor.stability = UNSTABLE_OPTION;
+          break;
+        case EVOLVING_OPTION:
+          RootDocProcessor.stability = EVOLVING_OPTION;
+          break;
+        case STABLE_OPTION:
+          RootDocProcessor.stability = STABLE_OPTION;
+          break;
+        default:
+          RootDocProcessor.stability = UNSTABLE_OPTION;
+          break;
       }
     }
   }
 
   public static String[][] filterOptions(String[][] options) {
     List<String[]> optionsList = new ArrayList<>();
-    for (int i = 0; i < options.length; i++) {
-      if (!options[i][0].equalsIgnoreCase(UNSTABLE_OPTION)
-          && !options[i][0].equalsIgnoreCase(EVOLVING_OPTION)
-          && !options[i][0].equalsIgnoreCase(STABLE_OPTION)) {
-        optionsList.add(options[i]);
+    for (String[] option : options) {
+      if (!option[0].equalsIgnoreCase(UNSTABLE_OPTION)
+          && !option[0].equalsIgnoreCase(EVOLVING_OPTION)
+          && !option[0].equalsIgnoreCase(STABLE_OPTION)) {
+        optionsList.add(option);
       }
     }
     String[][] filteredOptions = new String[optionsList.size()][];