FileDocCategorySizeDatePackage
Group.javaAPI DocExample10226Wed Apr 19 11:17:14 BST 2000com.sun.tools.doclets.standard

Group

public class Group extends Object
Process and manage grouping of packages, as specified by "-group" option on the command line.

For example, if user has used "-group option as -group "Core Packages" "java.*" -group "CORBA Packages" "org.omg.*", then the packages specified on the command line will be grouped according to their names starting with either "java." or "org.omg.". All the other packages which do not fall in the user given groups, are grouped in default group, named as either "Other Packages" or "Packages" depending upon if "-group" option used or not at all used respectively.

Also the packages are grouped according to the longest possible match of their names with the grouping information provided. For example, if there are two groups, like -group "Lang" "java.lang" and -group "Core" "java.*", will put the package java.lang in the group "Lang" and not in group "Core".

author
Atul M Dambalkar

Fields Summary
private static Map
regExpGroupMap
Map of regular expressions with the corresponding group name.
private static List
sortedRegExpList
List of regular expressions sorted according to the length. Regular expression with longest length will be first in the sorted order.
private static List
groupList
List of group names in the same order as given on the command line.
private static Map
pkgNameGroupMap
Map of non-regular expressions(possible package names) with the corresponding group name.
Constructors Summary
Methods Summary
static java.util.ListasList(java.lang.Object[] arr)
This is needed since Arrays.asList() raises UnSupportedOperationException.

        List list = new ArrayList();
        for (int i = 0; i < arr.length; i++) {
            list.add(arr[i]);
        }
        return list;
    
public static booleancheckPackageGroups(java.lang.String groupname, java.lang.String pkgNameFormList, com.sun.javadoc.DocErrorReporter reporter)
Depending upon the format of the package name provided in the "-group" option, generate two separate maps. There will be a map for mapping regular expression(only meta character allowed is '*' and that is at the end of the regular expression) on to the group name. And another map for mapping (possible) package names(if the name format doesen't contain meta character '*', then it is assumed to be a package name) on to the group name. This will also sort all the regular expressions found in the reverse order of their lengths, i.e. longest regular expression will be first in the sorted list.

param
groupname The name of the group from -group option.
param
pkgNameFormList List of the package name formats.
param
reporter Error reporter object.

        StringTokenizer strtok = new StringTokenizer(pkgNameFormList, ":");
        if (groupList.contains(groupname)) {
            reporter.printError(getText("doclet.Groupname_already_used", 
                                         groupname));
            return false;
        }
        groupList.add(groupname);
        while (strtok.hasMoreTokens()) {
            String id = strtok.nextToken();
            if (id.length() == 0) {
                reporter.printError(getText("doclet.Error_in_packagelist", 
                                             groupname, pkgNameFormList));
                return false;
            }
            if (id.endsWith("*")) {
                id = id.substring(0, id.length() - 1);
                if (foundGroupFormat(regExpGroupMap, id, reporter)) {
                    return false;
                } 
                regExpGroupMap.put(id, groupname);
                sortedRegExpList.add(id);
            } else {
                if (foundGroupFormat(pkgNameGroupMap, id, reporter)) {
                    return false;
                } 
                pkgNameGroupMap.put(id, groupname);
            }
        }
        Collections.sort(sortedRegExpList, new MapKeyComparator());
        return true;
    
static booleanfoundGroupFormat(java.util.Map map, java.lang.String pkgFormat, com.sun.javadoc.DocErrorReporter reporter)
Search if the given map has given the package format.

return
true if package name format found in the map, else false.
param
map Map to be searched.
param
pkgFormat The pacakge format to search.
param
reporter Error reporter object.

        if (map.containsKey(pkgFormat)) { 
            reporter.printError(getText("doclet.Same_package_name_used", 
                                         pkgFormat));
            return true;
        }
        return false;
    
public static java.util.ListgetGroupList()
Return the list of groups, in the same order as specified on the command line.

        return groupList;
    
static java.util.ListgetPkgList(java.util.Map map, java.lang.String groupname)
For the given group name, return the package list, on which it is mapped. Create a new list, if not found.

param
map Map to be searched for gorup name.
param
groupname Group name to search.

        List list = (List)map.get(groupname);
        if (list == null) {
            list = new ArrayList();
            map.put(groupname, list);
        }
        return list;
    
private static java.lang.StringgetText(java.lang.String text)
Retireve the message string from the resource bundle.

param
text Key for the resource message string.

        return Standard.configuration().standardmessage.getText(text);
    
private static java.lang.StringgetText(java.lang.String text, java.lang.String arg1, java.lang.String arg2)
Retireve the message string from the resource bundle.

param
text Key for the resource message string.
param
arg1 Argument to be substituted in the resource message string.
param
arg2 Argument to be substituted in the resource message string.

        return Standard.configuration().standardmessage.getText(text, 
                                                                arg1, arg2);
    
private static java.lang.StringgetText(java.lang.String text, java.lang.String arg)
Retireve the message string from the resource bundle.

param
text Key for the resource message string.
param
arg Argument to be substituted in the resource message string.

        return Standard.configuration().standardmessage.getText(text, arg);
    
public static java.util.MapgroupPackages(com.sun.javadoc.PackageDoc[] packages)
Group the packages according the grouping information provided on the command line. Given a list of packages, search each package name in regular expression map as well as package name map to get the corresponding group name. Create another map with mapping of group name to the package list, which will fall under the specified group. If any package doesen't belong to any specified group on the comamnd line, then a new group named "Other Packages" will be created for it. If there are no groups found, in other words if "-group" option is not at all used, then all the packages will be grouped under group "Packages".

param
packages Packages specified on the command line.

        Map groupPackageMap = new HashMap();
        String defaultGroupName = 
            (pkgNameGroupMap.isEmpty() && regExpGroupMap.isEmpty())? 
                getText("doclet.Packages") :
                getText("doclet.Other_Packages");
        // if the user has not used the default group name, add it
        if (!groupList.contains(defaultGroupName)) {
            groupList.add(defaultGroupName);
        }
        for (int i = 0; i < packages.length; i++) {
            PackageDoc pkg = packages[i];
            String pkgName = pkg.name();
            String groupName = (String)pkgNameGroupMap.get(pkgName);
            // if this package is not explictly assigned to a group,
            // try matching it to group specified by regular expression 
            if (groupName == null) {
                groupName = regExpGroupName(pkgName);
            }
            // if it is in neither group map, put it in the default
            // group
            if (groupName == null) {
                groupName = defaultGroupName;
            }
            getPkgList(groupPackageMap, groupName).add(pkg);
        }
        return groupPackageMap;
    
static java.lang.StringregExpGroupName(java.lang.String pkgName)
Search for package name in the sorted regular expression list, if found return the group name. If not, return null.

param
pkgName Name of package to be found in the regular expression list.

 
        for (int j = 0; j < sortedRegExpList.size(); j++) {
            String regexp = (String)sortedRegExpList.get(j); 
            if (pkgName.startsWith(regexp)) {
                return (String)regExpGroupMap.get(regexp);
            } 
        }
        return null;