changeset 46078:35994b07ed5e

8183026: minor cleanup for IndexUseComparator 8163990: Utils.ElementComparator does not need to be generic. Reviewed-by: jjg
author ksrini
date Fri, 28 Jul 2017 14:29:29 -0700
parents 08de9d5386a9
children 059faa5e1267
files langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java
diffstat 1 files changed, 171 insertions(+), 142 deletions(-) [+]
line wrap: on
line diff
--- a/langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java	Fri Jul 28 19:54:26 2017 +0800
+++ b/langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java	Fri Jul 28 14:29:29 2017 -0700
@@ -679,10 +679,11 @@
         }
     }
 
-   /**
+    /**
      * Get the signature. It is the parameter list, type is qualified.
      * For instance, for a method {@code mymethod(String x, int y)},
      * it will return {@code(java.lang.String,int)}.
+     *
      * @param e
      * @return String
      */
@@ -1674,19 +1675,24 @@
         }
     }
 
+    private Comparator<Element> moduleComparator = null;
     /**
      * Comparator for ModuleElements, simply compares the fully qualified names
      * @return a Comparator
      */
     public Comparator<Element> makeModuleComparator() {
-        return new Utils.ElementComparator<Element>() {
-            @Override
-            public int compare(Element mod1, Element mod2) {
-                return compareFullyQualifiedNames(mod1, mod2);
-            }
-        };
+        if (moduleComparator == null) {
+            moduleComparator = new Utils.ElementComparator() {
+                @Override
+                public int compare(Element mod1, Element mod2) {
+                    return compareFullyQualifiedNames(mod1, mod2);
+                }
+            };
+        }
+        return moduleComparator;
     }
 
+    private Comparator<Element> allClassesComparator = null;
     /**
      * Returns a Comparator for all classes, compares the simple names of
      * TypeElement, if equal then the fully qualified names.
@@ -1694,42 +1700,53 @@
      * @return Comparator
      */
     public Comparator<Element> makeAllClassesComparator() {
-        return new Utils.ElementComparator<Element>() {
-            @Override
-            public int compare(Element e1, Element e2) {
-                int result =  compareNames(e1, e2);
-                if (result == 0)
-                    result =  compareFullyQualifiedNames(e1, e2);
-
-                return result;
-            }
-        };
+        if (allClassesComparator == null) {
+            allClassesComparator = new Utils.ElementComparator() {
+                @Override
+                public int compare(Element e1, Element e2) {
+                    int result = compareNames(e1, e2);
+                    if (result == 0)
+                        result = compareFullyQualifiedNames(e1, e2);
+
+                    return result;
+                }
+            };
+        }
+        return allClassesComparator;
     }
 
+    private Comparator<Element> packageComparator = null;
     /**
      * Returns a Comparator for packages, by comparing the fully qualified names.
      *
      * @return a Comparator
      */
     public Comparator<Element> makePackageComparator() {
-        return new Utils.ElementComparator<Element>() {
-            @Override
-            public int compare(Element pkg1, Element pkg2) {
-                return compareFullyQualifiedNames(pkg1, pkg2);
-            }
-        };
+        if (packageComparator == null) {
+            packageComparator = new Utils.ElementComparator() {
+                @Override
+                public int compare(Element pkg1, Element pkg2) {
+                    return compareFullyQualifiedNames(pkg1, pkg2);
+                }
+            };
+        }
+        return packageComparator;
     }
 
+    private Comparator<SerialFieldTree> serialFieldTreeComparator = null;
     /**
      * Returns a Comparator for SerialFieldTree.
      * @return a Comparator
      */
     public Comparator<SerialFieldTree> makeSerialFieldTreeComparator() {
-        return (SerialFieldTree o1, SerialFieldTree o2) -> {
-            String s1 = o1.getName().toString();
-            String s2 = o2.getName().toString();
-            return s1.compareTo(s2);
-        };
+        if (serialFieldTreeComparator == null) {
+            serialFieldTreeComparator = (SerialFieldTree o1, SerialFieldTree o2) -> {
+                String s1 = o1.getName().toString();
+                String s2 = o2.getName().toString();
+                return s1.compareTo(s2);
+            };
+        }
+        return serialFieldTreeComparator;
     }
 
     /**
@@ -1740,6 +1757,7 @@
         return makeClassUseComparator();
     }
 
+    private Comparator<Element> overrideUseComparator = null;
     /**
      * Returns a Comparator for overrides and implements,
      * used primarily on methods, compares the name first,
@@ -1748,33 +1766,38 @@
      * @return a Comparator
      */
     public Comparator<Element> makeOverrideUseComparator() {
-        return new Utils.ElementComparator<Element>() {
-            @Override
-            public int compare(Element o1, Element o2) {
-                int result = compareStrings(getSimpleName(o1), getSimpleName(o2));
-                if (result != 0) {
-                    return result;
-                }
-                if (!isTypeElement(o1) && !isTypeElement(o2) && !isPackage(o1) && !isPackage(o2)) {
-                    TypeElement t1 = getEnclosingTypeElement(o1);
-                    TypeElement t2 = getEnclosingTypeElement(o2);
-                    result = compareStrings(getSimpleName(t1), getSimpleName(t2));
+        if (overrideUseComparator == null) {
+            overrideUseComparator = new Utils.ElementComparator() {
+                @Override
+                public int compare(Element o1, Element o2) {
+                    int result = compareStrings(getSimpleName(o1), getSimpleName(o2));
+                    if (result != 0) {
+                        return result;
+                    }
+                    if (!isTypeElement(o1) && !isTypeElement(o2) && !isPackage(o1) && !isPackage(o2)) {
+                        TypeElement t1 = getEnclosingTypeElement(o1);
+                        TypeElement t2 = getEnclosingTypeElement(o2);
+                        result = compareStrings(getSimpleName(t1), getSimpleName(t2));
+                        if (result != 0)
+                            return result;
+                    }
+                    result = compareStrings(getFullyQualifiedName(o1), getFullyQualifiedName(o2));
                     if (result != 0)
                         return result;
+                    return compareElementTypeKinds(o1, o2);
                 }
-                result = compareStrings(getFullyQualifiedName(o1), getFullyQualifiedName(o2));
-                if (result != 0)
-                    return result;
-                return compareElementTypeKinds(o1, o2);
-            }
-        };
+            };
+        }
+        return overrideUseComparator;
     }
 
+    private Comparator<Element> indexUseComparator = null;
     /**
-     * Returns a Comparator for index file presentations, and are sorted as follows.
-     *  If comparing modules and packages then simply compare the qualified names, if comparing a module
-     *  or a package with a type/member then compare the FullyQualifiedName of the module or a package
-     *  with the SimpleName of the entity, otherwise
+     *  Returns a Comparator for index file presentations, and are sorted as follows.
+     *  If comparing modules and/or packages then simply compare the qualified names,
+     *  if comparing a module or a package with a type/member then compare the
+     *  FullyQualifiedName of the module or a package with the SimpleName of the entity,
+     *  otherwise:
      *  1. compare the ElementKind ex: Module, Package, Interface etc.
      *  2a. if equal and if the type is of ExecutableElement(Constructor, Methods),
      *      a case insensitive comparison of parameter the type signatures
@@ -1783,73 +1806,76 @@
      * @return a comparator for index file use
      */
     public Comparator<Element> makeIndexUseComparator() {
-        return new Utils.ElementComparator<Element>() {
-            /**
-             * Compare two given elements, if comparing two modules or two packages, return the
-             * comparison of FullyQualifiedName, if comparing a module or a package with a
-             * type/member then compare the FullyQualifiedName of the module or the package
-             * with the SimpleName of the entity, then sort on the kinds, then on
-             * the parameters only if the type is an ExecutableElement,
-             * the parameters are compared and finally the qualified names.
-             *
-             * @param e1 - an element.
-             * @param e2 - an element.
-             * @return a negative integer, zero, or a positive integer as the first
-             *         argument is less than, equal to, or greater than the second.
-             */
-            @Override
-            public int compare(Element e1, Element e2) {
-                int result = 0;
-                if ((isModule(e1) || isPackage(e1)) && (isModule(e2) || isPackage(e2))) {
-                    result = compareFullyQualifiedNames(e1, e2);
+        if (indexUseComparator == null) {
+            indexUseComparator = new Utils.ElementComparator() {
+                /**
+                 * Compares two elements.
+                 *
+                 * @param e1 - an element.
+                 * @param e2 - an element.
+                 * @return a negative integer, zero, or a positive integer as the first
+                 * argument is less than, equal to, or greater than the second.
+                 */
+                @Override
+                public int compare(Element e1, Element e2) {
+                    int result;
+                    // first, compare names as appropriate
+                    if ((isModule(e1) || isPackage(e1)) && (isModule(e2) || isPackage(e2))) {
+                        result = compareFullyQualifiedNames(e1, e2);
+                    } else if (isModule(e1) || isPackage(e1)) {
+                        result = compareStrings(getFullyQualifiedName(e1), getSimpleName(e2));
+                    } else if (isModule(e2) || isPackage(e2)) {
+                        result = compareStrings(getSimpleName(e1), getFullyQualifiedName(e2));
+                    } else {
+                        result = compareNames(e1, e2);
+                    }
                     if (result != 0) {
                         return result;
                     }
-                    return compareElementTypeKinds(e1, e2);
-                }
-                if (isModule(e1) || isPackage(e1)) {
-                    result = compareStrings(getFullyQualifiedName(e1), getSimpleName(e2));
-                } else if (isModule(e2) || isPackage(e2)) {
-                    result = compareStrings(getSimpleName(e1), getFullyQualifiedName(e2));
-                } else {
-                    result = compareNames(e1, e2);
-                }
-                if (result != 0) {
-                    return result;
-                }
-                result = compareElementTypeKinds(e1, e2);
-                if (result != 0) {
-                    return result;
-                }
-                if (hasParameters(e1)) {
-                    List<? extends VariableElement> parameters1 = ((ExecutableElement)e1).getParameters();
-                    List<? extends VariableElement> parameters2 = ((ExecutableElement)e2).getParameters();
-                    result = compareParameters(false, parameters1, parameters2);
+                    // if names are the same, compare element kinds
+                    result = compareElementTypeKinds(e1, e2);
                     if (result != 0) {
                         return result;
                     }
-                    result = compareParameters(true, parameters1, parameters2);
-                    if (result != 0) {
-                        return result;
+                    // if element kinds are the same, and are methods,
+                    // compare the method parameters
+                    if (hasParameters(e1)) {
+                        List<? extends VariableElement> parameters1 = ((ExecutableElement)e1).getParameters();
+                        List<? extends VariableElement> parameters2 = ((ExecutableElement)e2).getParameters();
+                        result = compareParameters(false, parameters1, parameters2);
+                        if (result != 0) {
+                            return result;
+                        }
+                        result = compareParameters(true, parameters1, parameters2);
+                        if (result != 0) {
+                            return result;
+                        }
                     }
+                    // else fall back on fully qualified names
+                    return compareFullyQualifiedNames(e1, e2);
                 }
-                return compareFullyQualifiedNames(e1, e2);
-            }
-        };
+            };
+        }
+        return indexUseComparator;
     }
 
+    private Comparator<TypeMirror> typeMirrorClassUseComparator = null;
     /**
      * Compares the FullyQualifiedNames of two TypeMirrors
      * @return
      */
     public Comparator<TypeMirror> makeTypeMirrorClassUseComparator() {
-        return (TypeMirror type1, TypeMirror type2) -> {
-            String s1 = getQualifiedTypeName(type1);
-            String s2 = getQualifiedTypeName(type2);
-            return compareStrings(s1, s2);
-        };
+        if (typeMirrorClassUseComparator == null) {
+            typeMirrorClassUseComparator = (TypeMirror type1, TypeMirror type2) -> {
+                String s1 = getQualifiedTypeName(type1);
+                String s2 = getQualifiedTypeName(type2);
+                return compareStrings(s1, s2);
+            };
+        }
+        return typeMirrorClassUseComparator;
     }
 
+    private Comparator<TypeMirror> typeMirrorIndexUseComparator = null;
     /**
      * Compares the SimpleNames of TypeMirrors if equal then the
      * FullyQualifiedNames of TypeMirrors.
@@ -1857,12 +1883,15 @@
      * @return
      */
     public Comparator<TypeMirror> makeTypeMirrorIndexUseComparator() {
-        return (TypeMirror t1, TypeMirror t2) -> {
-            int result = compareStrings(getTypeName(t1, false), getTypeName(t2, false));
-            if (result != 0)
-                return result;
-            return compareStrings(getQualifiedTypeName(t1), getQualifiedTypeName(t2));
-        };
+        if (typeMirrorIndexUseComparator == null) {
+            typeMirrorIndexUseComparator = (TypeMirror t1, TypeMirror t2) -> {
+                int result = compareStrings(getTypeName(t1, false), getTypeName(t2, false));
+                if (result != 0)
+                    return result;
+                return compareStrings(getQualifiedTypeName(t1), getQualifiedTypeName(t2));
+            };
+        }
+        return typeMirrorIndexUseComparator;
     }
 
     /**
@@ -1936,6 +1965,7 @@
         }.visit(e);
     }
 
+    private Comparator<Element> classUseComparator = null;
     /**
      * Comparator for ClassUse presentations, and sorts as follows:
      * 1. member names
@@ -1945,51 +1975,52 @@
      * @return a comparator to sort classes and members for class use
      */
     public Comparator<Element> makeClassUseComparator() {
-        return new Utils.ElementComparator<Element>() {
-            /**
-             * Compare two Elements, first sort on simple name, and if
-             * applicable on the fully qualified name, and finally if applicable
-             * on the parameter types.
-             * @param e1 - an element.
-             * @param e2 - an element.
-             * @return a negative integer, zero, or a positive integer as the first
-             *         argument is less than, equal to, or greater than the second.
-             */
-            @Override
-            public int compare(Element e1, Element e2) {
-                int result = compareNames(e1, e2);
-                if (result != 0) {
-                    return result;
-                }
-                result = compareFullyQualifiedNames(e1, e2);
-                if (result != 0) {
-                    return result;
-                }
-                if (hasParameters(e1) && hasParameters(e2)) {
-                    @SuppressWarnings("unchecked")
-                    List<VariableElement> parameters1 = (List<VariableElement>) ((ExecutableElement)e1).getParameters();
-                    @SuppressWarnings("unchecked")
-                    List<VariableElement> parameters2 = (List<VariableElement>) ((ExecutableElement)e2).getParameters();
-                    result =  compareParameters(false, parameters1, parameters2);
+        if (classUseComparator == null) {
+            classUseComparator = new Utils.ElementComparator() {
+                /**
+                 * Compares two Elements.
+                 *
+                 * @param e1 - an element.
+                 * @param e2 - an element.
+                 * @return a negative integer, zero, or a positive integer as the first
+                 * argument is less than, equal to, or greater than the second.
+                 */
+                @Override
+                public int compare(Element e1, Element e2) {
+                    int result = compareNames(e1, e2);
                     if (result != 0) {
                         return result;
                     }
-                    result =  compareParameters(true, parameters1, parameters2);
+                    result = compareFullyQualifiedNames(e1, e2);
+                    if (result != 0) {
+                        return result;
+                    }
+                    if (hasParameters(e1) && hasParameters(e2)) {
+                        @SuppressWarnings("unchecked")
+                        List<VariableElement> parameters1 = (List<VariableElement>)((ExecutableElement)e1).getParameters();
+                        @SuppressWarnings("unchecked")
+                        List<VariableElement> parameters2 = (List<VariableElement>)((ExecutableElement)e2).getParameters();
+                        result = compareParameters(false, parameters1, parameters2);
+                        if (result != 0) {
+                            return result;
+                        }
+                        result = compareParameters(true, parameters1, parameters2);
+                    }
+                    if (result != 0) {
+                        return result;
+                    }
+                    return compareElementTypeKinds(e1, e2);
                 }
-                if (result != 0) {
-                    return result;
-                }
-                return compareElementTypeKinds(e1, e2);
-            }
-        };
+            };
+        }
+        return classUseComparator;
     }
 
     /**
      * A general purpose comparator to sort Element entities, basically provides the building blocks
      * for creating specific comparators for an use-case.
-     * @param <T> an Element
      */
-    private abstract class ElementComparator<T extends Element> implements Comparator<Element> {
+    private abstract class ElementComparator implements Comparator<Element> {
         /**
          * compares two parameter arrays by first comparing the length of the arrays, and
          * then each Type of the parameter in the array.
@@ -2097,8 +2128,6 @@
         /**
          * The fully qualified names of the entities, used solely by the comparator.
          *
-         * @param p1 the first Element.
-         * @param p2 the first Element.
          * @return a negative integer, zero, or a positive integer as the first argument is less
          * than, equal to, or greater than the second.
          */