Java ElementFilter.packagesIn方法代碼示例

import javax.lang.model.util.ElementFilter; //導入方法依賴的package包/類
/**
 * Add class listing for all the classes in this module. Divide class
 * listing as per the class kind and generate separate listing for
 * Classes, Interfaces, Exceptions and Errors.
 *
 * @param contentTree the content tree to which the listing will be added
 */
protected void addClassListing(HtmlTree contentTree) {
    List<PackageElement> packagesIn = ElementFilter.packagesIn(mdle.getEnclosedElements());
    SortedSet<TypeElement> interfaces = new TreeSet<>(utils.makeGeneralPurposeComparator());
    SortedSet<TypeElement> classes = new TreeSet<>(utils.makeGeneralPurposeComparator());
    SortedSet<TypeElement> enums = new TreeSet<>(utils.makeGeneralPurposeComparator());
    SortedSet<TypeElement> exceptions = new TreeSet<>(utils.makeGeneralPurposeComparator());
    SortedSet<TypeElement> errors = new TreeSet<>(utils.makeGeneralPurposeComparator());
    SortedSet<TypeElement> annotationTypes = new TreeSet<>(utils.makeGeneralPurposeComparator());
    for (PackageElement pkg : packagesIn) {
        if (utils.isIncluded(pkg)) {
            interfaces.addAll(utils.getInterfaces(pkg));
            classes.addAll(utils.getOrdinaryClasses(pkg));
            enums.addAll(utils.getEnums(pkg));
            exceptions.addAll(utils.getExceptions(pkg));
            errors.addAll(utils.getErrors(pkg));
            annotationTypes.addAll(utils.getAnnotationTypes(pkg));
        }
    }
    addClassKindListing(interfaces, contents.interfaces, contentTree);
    addClassKindListing(classes, contents.classes, contentTree);
    addClassKindListing(enums, contents.enums, contentTree);
    addClassKindListing(exceptions, contents.exceptions, contentTree);
    addClassKindListing(errors, contents.errors, contentTree);
    addClassKindListing(annotationTypes, contents.annotationTypes, contentTree);
}
 

import javax.lang.model.util.ElementFilter; //導入方法依賴的package包/類
Set<Element> getAllSelectedElements(DocletEnvironment docenv) {
    Set<Element> result = new TreeSet<Element>((Element e1, Element e2) -> {
        // some grouping by kind preferred
        int rc = e1.getKind().compareTo(e2.getKind());
        if (rc != 0) return rc;
        rc = e1.toString().compareTo(e2.toString());
        if (rc != 0) return rc;
        return Integer.compare(e1.hashCode(), e2.hashCode());
    });
    Set<? extends Element> elements = docenv.getIncludedElements();
    for (ModuleElement me : ElementFilter.modulesIn(elements)) {
        addEnclosedElements(docenv, result, me);
    }
    for (PackageElement pe : ElementFilter.packagesIn(elements)) {
        ModuleElement mdle = docenv.getElementUtils().getModuleOf(pe);
        if (mdle != null)
            addEnclosedElements(docenv, result, mdle);
        addEnclosedElements(docenv, result, pe);
    }
    for (TypeElement te : ElementFilter.typesIn(elements)) {
        addEnclosedElements(docenv, result, te);
    }
    return result;
}
 

import javax.lang.model.util.ElementFilter; //導入方法依賴的package包/類
private Set<PackageElement> computeModulePackages() throws ToolException {
    AccessKind accessValue = accessFilter.getAccessValue(ElementKind.PACKAGE);
    final boolean documentAllModulePackages = (accessValue == AccessKind.PACKAGE ||
            accessValue == AccessKind.PRIVATE);

    accessValue = accessFilter.getAccessValue(ElementKind.MODULE);
    final boolean moduleDetailedMode = (accessValue == AccessKind.PACKAGE ||
            accessValue == AccessKind.PRIVATE);
    Set<PackageElement> expandedModulePackages = new LinkedHashSet<>();

    for (ModuleElement mdle : specifiedModuleElements) {
        if (documentAllModulePackages) { // include all packages
            List<PackageElement> packages = ElementFilter.packagesIn(mdle.getEnclosedElements());
            expandedModulePackages.addAll(packages);
            expandedModulePackages.addAll(getAllModulePackages(mdle));
        } else { // selectively include required packages
            List<ExportsDirective> exports = ElementFilter.exportsIn(mdle.getDirectives());
            for (ExportsDirective export : exports) {
                // add if fully exported or add qualified exports only if desired
                if (export.getTargetModules() == null
                        || documentAllModulePackages || moduleDetailedMode) {
                    expandedModulePackages.add(export.getPackage());
                }
            }
        }

        // add all packages specified on the command line
        // belonging to this module
        if (!cmdLinePackages.isEmpty()) {
            for (ModulePackage modpkg : cmdLinePackages) {
                PackageElement pkg = toolEnv.elements.getPackageElement(mdle,
                        modpkg.packageName);
                if (pkg != null) {
                    expandedModulePackages.add(pkg);
                }
            }
        }
    }
    return expandedModulePackages;
}