jdk-sandbox: comparison langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java

equal deleted inserted replaced

-:08de9d5386a9
+:35994b07ed5e
 default:
 return false;
 }
 }
 /**
 * 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
 */
 public String signature(ExecutableElement e) {
 return makeSignature(e, true);
 public int compare(String s1, String s2) {
 return getKey(s1).compareTo(getKey(s2));
 }
 }
+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>() {
+if (moduleComparator == null) {
-@Override
+moduleComparator = new Utils.ElementComparator() {
-public int compare(Element mod1, Element mod2) {
+@Override
-return compareFullyQualifiedNames(mod1, mod2);
+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.
 *
 * @return Comparator
 */
 public Comparator<Element> makeAllClassesComparator() {
-return new Utils.ElementComparator<Element>() {
+if (allClassesComparator == null) {
-@Override
+allClassesComparator = new Utils.ElementComparator() {
-public int compare(Element e1, Element e2) {
+@Override
-int result =  compareNames(e1, e2);
+public int compare(Element e1, Element e2) {
-if (result == 0)
+int result = compareNames(e1, e2);
-result =  compareFullyQualifiedNames(e1, e2);
+if (result == 0)
+result = compareFullyQualifiedNames(e1, e2);
-return result;
-}
+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>() {
+if (packageComparator == null) {
-@Override
+packageComparator = new Utils.ElementComparator() {
-public int compare(Element pkg1, Element pkg2) {
+@Override
-return compareFullyQualifiedNames(pkg1, pkg2);
+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) -> {
+if (serialFieldTreeComparator == null) {
-String s1 = o1.getName().toString();
+serialFieldTreeComparator = (SerialFieldTree o1, SerialFieldTree o2) -> {
-String s2 = o2.getName().toString();
+String s1 = o1.getName().toString();
-return s1.compareTo(s2);
+String s2 = o2.getName().toString();
-};
+return s1.compareTo(s2);
+};
+}
+return serialFieldTreeComparator;
 }
 /**
 * Returns a general purpose comparator.
 * @return a Comparator
 */
 public Comparator<Element> makeGeneralPurposeComparator() {
 return makeClassUseComparator();
 }
+private Comparator<Element> overrideUseComparator = null;
 /**
 * Returns a Comparator for overrides and implements,
 * used primarily on methods, compares the name first,
 * then compares the simple names of the enclosing
 * TypeElement and the fully qualified name of the enclosing TypeElement.
 * @return a Comparator
 */
 public Comparator<Element> makeOverrideUseComparator() {
-return new Utils.ElementComparator<Element>() {
+if (overrideUseComparator == null) {
-@Override
+overrideUseComparator = new Utils.ElementComparator() {
-public int compare(Element o1, Element o2) {
+@Override
-int result = compareStrings(getSimpleName(o1), getSimpleName(o2));
+public int compare(Element o1, Element o2) {
-if (result != 0) {
+int result = compareStrings(getSimpleName(o1), getSimpleName(o2));
-return result;
+if (result != 0) {
-}
+return result;
-if (!isTypeElement(o1) && !isTypeElement(o2) && !isPackage(o1) && !isPackage(o2)) {
+}
-TypeElement t1 = getEnclosingTypeElement(o1);
+if (!isTypeElement(o1) && !isTypeElement(o2) && !isPackage(o1) && !isPackage(o2)) {
-TypeElement t2 = getEnclosingTypeElement(o2);
+TypeElement t1 = getEnclosingTypeElement(o1);
-result = compareStrings(getSimpleName(t1), getSimpleName(t2));
+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.
-* 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 modules and packages then simply compare the qualified names, if comparing a module
+*  if comparing a module or a package with a type/member then compare the
-*  or a package with a type/member then compare the FullyQualifiedName of the module or a package
+*  FullyQualifiedName of the module or a package with the SimpleName of the entity,
-*  with the SimpleName of the entity, otherwise
+*  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
 *  2b. if equal, case sensitive comparison of the type signatures
 *  3. finally, if equal, compare the FQNs of the entities
 * @return a comparator for index file use
 */
 public Comparator<Element> makeIndexUseComparator() {
-return new Utils.ElementComparator<Element>() {
+if (indexUseComparator == null) {
-/**
+indexUseComparator = new Utils.ElementComparator() {
-* 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
+* Compares two elements.
-* 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
+* @param e1 - an element.
-* the parameters only if the type is an ExecutableElement,
+* @param e2 - an element.
-* the parameters are compared and finally the qualified names.
+* @return a negative integer, zero, or a positive integer as the first
-*
+* argument is less than, equal to, or greater than the second.
-* @param e1 - an element.
+*/
-* @param e2 - an element.
+@Override
-* @return a negative integer, zero, or a positive integer as the first
+public int compare(Element e1, Element e2) {
-*         argument is less than, equal to, or greater than the second.
+int result;
-*/
+// first, compare names as appropriate
-@Override
+if ((isModule(e1) || isPackage(e1)) && (isModule(e2) || isPackage(e2))) {
-public int compare(Element e1, Element e2) {
+result = compareFullyQualifiedNames(e1, e2);
-int result = 0;
+} else if (isModule(e1) || isPackage(e1)) {
-if ((isModule(e1) || isPackage(e1)) && (isModule(e2) || isPackage(e2))) {
+result = compareStrings(getFullyQualifiedName(e1), getSimpleName(e2));
-result = compareFullyQualifiedNames(e1, 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 names are the same, compare element kinds
-}
+result = 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 (result != 0) {
 return result;
 }
-result = compareParameters(true, parameters1, parameters2);
+// if element kinds are the same, and are methods,
-if (result != 0) {
+// compare the method parameters
-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 (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 indexUseComparator;
+}
+private Comparator<TypeMirror> typeMirrorClassUseComparator = null;
 /**
 * Compares the FullyQualifiedNames of two TypeMirrors
 * @return
 */
 public Comparator<TypeMirror> makeTypeMirrorClassUseComparator() {
-return (TypeMirror type1, TypeMirror type2) -> {
+if (typeMirrorClassUseComparator == null) {
-String s1 = getQualifiedTypeName(type1);
+typeMirrorClassUseComparator = (TypeMirror type1, TypeMirror type2) -> {
-String s2 = getQualifiedTypeName(type2);
+String s1 = getQualifiedTypeName(type1);
-return compareStrings(s1, s2);
+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.
 *
 * @return
 */
 public Comparator<TypeMirror> makeTypeMirrorIndexUseComparator() {
-return (TypeMirror t1, TypeMirror t2) -> {
+if (typeMirrorIndexUseComparator == null) {
-int result = compareStrings(getTypeName(t1, false), getTypeName(t2, false));
+typeMirrorIndexUseComparator = (TypeMirror t1, TypeMirror t2) -> {
-if (result != 0)
+int result = compareStrings(getTypeName(t1, false), getTypeName(t2, false));
-return result;
+if (result != 0)
-return compareStrings(getQualifiedTypeName(t1), getQualifiedTypeName(t2));
+return result;
-};
+return compareStrings(getQualifiedTypeName(t1), getQualifiedTypeName(t2));
+};
+}
+return typeMirrorIndexUseComparator;
 }
 /**
 * Get the qualified type name of a TypeMiror compatible with the Element's
 * getQualified name, returns  the qualified name of the Reference type
 return outer ? visit(e.getEnclosingElement()) : e.getSimpleName().toString();
 }
 }.visit(e);
 }
+private Comparator<Element> classUseComparator = null;
 /**
 * Comparator for ClassUse presentations, and sorts as follows:
 * 1. member names
 * 2. then fully qualified member names
 * 3. then parameter types if applicable
 * 4. finally the element kinds ie. package, class, interface etc.
 * @return a comparator to sort classes and members for class use
 */
 public Comparator<Element> makeClassUseComparator() {
-return new Utils.ElementComparator<Element>() {
+if (classUseComparator == null) {
-/**
+classUseComparator = new Utils.ElementComparator() {
-* Compare two Elements, first sort on simple name, and if
+/**
-* applicable on the fully qualified name, and finally if applicable
+* Compares two Elements.
-* 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.
+* 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 (result != 0) {
 return result;
 }
-result =  compareParameters(true, parameters1, parameters2);
+result = compareFullyQualifiedNames(e1, e2);
-}
+if (result != 0) {
-if (result != 0) {
+return result;
-return result;
+}
-}
+if (hasParameters(e1) && hasParameters(e2)) {
-return compareElementTypeKinds(e1, 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);
+}
+};
+}
+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 implements Comparator<Element> {
-private abstract class ElementComparator<T extends Element> 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.
 * @param params1 the first parameter array.
 * @param params2 the first parameter array.
 }
 /**
 * 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.
 */
 private String getFullyQualifiedName(Element e) {
 return new SimpleElementVisitor9<String, Void>() {

changeset 46078	35994b07ed5e
parent 45864	ac6c2a3326d2
child 46079	059faa5e1267