import jdepend.framework.PackageFilter; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static PackageAnalyser of(File classDir, final String packagePrefix) {
    final PackageFilter filter = new PackageFilter() {

        @Override
        public boolean accept(String name) {
            return name.startsWith(packagePrefix);
        }

    };
    final JDepend depend = new JDepend(filter);
    try {
        depend.addDirectory(classDir.getPath());
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }
    final Collection<JavaPackage> packages = depend.analyze();
    return new PackageAnalyser(packages);
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
public static JDepend getJDependInstance() {
    PackageFilter filter = new PackageFilter();
    IPreferenceStore settings = getDefault().getPreferenceStore();
    if (settings.getBoolean(JDependConstants.PREF_USE_FILTERS)) {
        String[] strings =
                parseList(settings.getString(JDependConstants.PREF_ACTIVE_FILTERS_LIST));
        for (String name : strings) {
            if (name.endsWith(".*")) {
                name = name.substring(0, name.length()-2);
            }
            filter.addPackage(name);
        }
    }
    JDepend jdepend = new JDepend(filter);
    return jdepend;
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
/**
 * Create processor running jdepend analyze
 *
 * @param sw destination writer for jdepend analyze,
 *   results of the jdepend analyze are written here
 * @return JDependProcessorXML created jdepend processor
 */
protected JDependProcessorXML2 createJDependProcessor(Writer sw ) {
    
    // read settings from JDependSettings
    
    // (1) setup the filter packages
    final PackageFilter fp = new PackageFilter();
    final JDependSettings settings = JDependSettings.getDefault();
    String[] filterPackages = settings.getFilterPackages();
    for (int i = 0; i < filterPackages.length; i++ ) {
        final String filterPackage = filterPackages[i];
        fp.addPackage( filterPackage );
    }
    // (2) analyze inner classes flag
    final boolean analyzeInnerClasses = settings.getAnalyzerInnerClasses();
    
    // (3) Create a print writer
    final PrintWriter pw = new PrintWriter(sw);
    
    // (3) create the processor
    final JDependProcessorXML2 jdp = new JDependProcessorXML2(pw);
    // (3.1) set options
    jdp.analyzeInnerClasses( analyzeInnerClasses );
    jdp.setFilter( fp );
    
    return jdp;
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
/**
 * @return result of JDepend run, never null
 */
public List<JavaPackage> analyze(TreeFolder newRoot, IResource[] resource) {
    resourceMap.clear();
    if (resource == null) {
        return new ArrayList<JavaPackage>();
    }

    JDepend jdepend =  JDepend4EclipsePlugin.getJDependInstance();
    PackageFilter filter = jdepend.getFilter();

    for (int i = 0; i < resource.length; i++) {
        TreeFolder [] tp = createTree(resource[i], filter);
        for (int j = 0; j < tp.length; j++) {
            // tree object check if child is exist
            if(tp[j].hasChildren()) {
                newRoot.addChild(tp[j]);
            }
        }
    }
    List<JavaPackage> packages = runJDepend(jdepend, newRoot.getChildren());
    // update cycle info
    // set cycle to true, if one of packages is under the founded tree root
    for (int j = 0; j < packages.size(); j++) {
        JavaPackage jp = packages.get(j);
        boolean cycle = jp.containsCycle();
        if(cycle){
            if(jp.getName().length() == 0){
                newRoot.setContainsCycle(cycle);
                continue;
            }
            TreeObject child = newRoot.findChild(jp);
            if(child != null && !child.isLeaf()){
                ((TreeFolder)child).setContainsCycle(cycle);
            }
        }
    }
    return packages;
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
private static List<JavaPackage> filterPackages(List<?> packages, JDepend jdepend){
    ArrayList<JavaPackage> filteredPackages = new ArrayList<JavaPackage>();
    PackageFilter filter = jdepend.getFilter();
    for (int i = 0; i < packages.size(); i++) {
        JavaPackage tempPackage = (JavaPackage)packages.get(i);
        if(filter.accept(tempPackage.getName())){
            filteredPackages.add(tempPackage);
        }
    }
    return filteredPackages;
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
private static void generateOverviewSummary(RootDoc root, ClassDocGraph graph, File outputDirectory) throws IOException {
    final Map<String, PackageDoc> packages = getPackages(root);

    PackageFilter packageFilter = PackageFilter.all();

    for (Map.Entry<String, PackageDoc> entry : packages.entrySet()) {
        String packageName = entry.getKey();
        PackageDoc p = entry.getValue();

        if (!ClassDocGraph.isHidden(p)) {
            packageFilter.including(packageName);
        }
    }

    JDepend jdepend = new JDepend(packageFilter.excludingRest());

    File[] classPath = getClassPath(root.options());
    for (File e: classPath) {
        if (e.isDirectory()) {
            root.printNotice(
                    "Included into dependency analysis: " + e);
            jdepend.addDirectory(e.toString());
        } else {
            root.printNotice(
                    "Excluded from dependency analysis: " + e);
        }
    }

    jdepend.analyze();

    if (checkClasspathOption(root, jdepend)) {
        instrumentDiagram(
                root, outputDirectory, "overview-summary",
                graph.getOverviewSummaryDiagram(jdepend));
    } else {
        root.printWarning(
                "Please make sure that the '" +
                OPTION_SOURCE_CLASS_PATH +
                "' option was specified correctly.");
        root.printWarning(
                "Package dependency diagram will not be generated " +
                "to avoid the inaccurate result.");
    }
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
@BeforeClass
public static void init() throws IOException {
    depend = new JDepend(PackageFilter.all().including("ch.docksnet").excludingRest());
    depend.addDirectory("out/production/intellij-reference-diagram");
    depend.analyze();
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
/**
 * Sets the package filter.
 *
 * @param filter Package filter.
 */
public void setFilter(PackageFilter filter) {
    analyzer.setFilter(filter);
}
 

import jdepend.framework.PackageFilter; //导入依赖的package包/类
/**
 * Sets the package filter.
 * 
 * @param filter Package filter.
 */
public void setFilter(PackageFilter filter) {
    analyzer.setFilter(filter);
}