jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/Util.java

equal deleted inserted replaced

-:1dff24b5f407
+:d0f233085cbb
 *
 * @param  members    Array of members to choose from.
 * @return List       List of eligible members for whom
 *                    documentation is getting generated.
 */
-public static List excludeDeprecatedMembersAsList(
+public static List<ProgramElementDoc> excludeDeprecatedMembersAsList(
 ProgramElementDoc[] members) {
-List list = new ArrayList();
+List<ProgramElementDoc> list = new ArrayList<ProgramElementDoc>();
 for (int i = 0; i < members.length; i++) {
 if (members[i].tags("deprecated").length == 0) {
 list.add(members[i]);
 }
 }
 /**
 * We want the list of types in alphabetical order.  However, types are not
 * comparable.  We need a comparator for now.
 */
-private static class TypeComparator implements Comparator {
+private static class TypeComparator implements Comparator<Type> {
-public int compare(Object type1, Object type2) {
+public int compare(Type type1, Type type2) {
-return ((Type) type1).qualifiedTypeName().toLowerCase().compareTo(
+return type1.qualifiedTypeName().toLowerCase().compareTo(
-((Type) type2).qualifiedTypeName().toLowerCase());
+type2.qualifiedTypeName().toLowerCase());
 }
 }
 /**
 * For the class return all implemented interfaces including the
 *                    super interfaces are sought.
 * @param  configuration the current configuration of the doclet.
 * @param  sort if true, return list of interfaces sorted alphabetically.
 * @return List of all the required interfaces.
 */
-public static List getAllInterfaces(Type type,
+public static List<Type> getAllInterfaces(Type type,
 Configuration configuration, boolean sort) {
-Map results = sort ? new TreeMap() : new LinkedHashMap();
+Map<ClassDoc,Type> results = sort ? new TreeMap<ClassDoc,Type>() : new LinkedHashMap<ClassDoc,Type>();
 Type[] interfaceTypes = null;
 Type superType = null;
 if (type instanceof ParameterizedType) {
 interfaceTypes = ((ParameterizedType) type).interfaceTypes();
 superType = ((ParameterizedType) type).superclassType();
 Type t = (Type) iter.next();
 results.put(t.asClassDoc(), t);
 }
 }
 if (superType == null)
-return new ArrayList(results.values());
+return new ArrayList<Type>(results.values());
 //Try walking the tree.
 addAllInterfaceTypes(results,
 superType,
 superType instanceof ClassDoc ?
 ((ClassDoc) superType).interfaceTypes() :
 ((ParameterizedType) superType).interfaceTypes(),
 false, configuration);
-List resultsList = new ArrayList(results.values());
+List<Type> resultsList = new ArrayList<Type>(results.values());
 if (sort) {
 Collections.sort(resultsList, new TypeComparator());
 }
 return resultsList;
 }
 public static List getAllInterfaces(Type type, Configuration configuration) {
 return getAllInterfaces(type, configuration, true);
 }
-private static void findAllInterfaceTypes(Map results, ClassDoc c, boolean raw,
+private static void findAllInterfaceTypes(Map<ClassDoc,Type> results, ClassDoc c, boolean raw,
 Configuration configuration) {
 Type superType = c.superclassType();
 if (superType == null)
 return;
 addAllInterfaceTypes(results, superType,
 ((ClassDoc) superType).interfaceTypes() :
 ((ParameterizedType) superType).interfaceTypes(),
 raw, configuration);
 }
-private static void findAllInterfaceTypes(Map results, ParameterizedType p,
+private static void findAllInterfaceTypes(Map<ClassDoc,Type> results, ParameterizedType p,
 Configuration configuration) {
 Type superType = p.superclassType();
 if (superType == null)
 return;
 addAllInterfaceTypes(results, superType,
 ((ClassDoc) superType).interfaceTypes() :
 ((ParameterizedType) superType).interfaceTypes(),
 false, configuration);
 }
-private static void addAllInterfaceTypes(Map results, Type type,
+private static void addAllInterfaceTypes(Map<ClassDoc,Type> results, Type type,
 Type[] interfaceTypes, boolean raw,
 Configuration configuration) {
 for (int i = 0; i < interfaceTypes.length; i++) {
 Type interfaceType = interfaceTypes[i];
 ClassDoc interfaceClassDoc = interfaceType.asClassDoc();
 else
 findAllInterfaceTypes(results, (ClassDoc) type, true, configuration);
 }
-public static List asList(ProgramElementDoc[] members) {
+public static List<ProgramElementDoc> asList(ProgramElementDoc[] members) {
-List list = new ArrayList();
+List<ProgramElementDoc> list = new ArrayList<ProgramElementDoc>();
 for (int i = 0; i < members.length; i++) {
 list.add(members[i]);
 }
 return list;
 }
 *                  to the end of the last token.
 *
 * @return an array of tokens.
 */
 public static String[] tokenize(String s, char separator, int maxTokens) {
-List tokens = new ArrayList();
+List<String> tokens = new ArrayList<String>();
 StringBuilder  token = new StringBuilder ();
 boolean prevIsEscapeChar = false;
 for (int i = 0; i < s.length(); i += Character.charCount(i)) {
 int currentChar = s.codePointAt(i);
 if (prevIsEscapeChar) {
 }
 }
 if (token.length() > 0) {
 tokens.add(token.toString());
 }
-return (String[]) tokens.toArray(new String[] {});
+return tokens.toArray(new String[] {});
 }
 /**
 * Return true if this class is linkable and false if we can't link to the
 * desired class.

changeset 868	d0f233085cbb
parent 10	06bc494ca11e
child 1264	076a3cde30d5