Java ClassPathSupport.createProxyClassPath方法代码示例

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
private ClassPath createCP(Project prj, HashSet<Project> parents) {
    parents.add(prj);
    List<ClassPath> list = new ArrayList<ClassPath>();
    ProjectSourcesClassPathProvider cpp = prj.getLookup().lookup(ProjectSourcesClassPathProvider.class);
    ClassPath[] cp = cpp.getProjectClassPaths(ClassPath.EXECUTE);
    list.addAll(Arrays.asList(cp));
    //for pom packaging projects subprojects/modules matter
    //TODO for application project it's DependencyProjectProvider, for pom project (run-ide?) it's containerprojectprovider
    SubprojectProvider spp = prj.getLookup().lookup(SubprojectProvider.class);
    if (spp != null) {
        for (Project sub : spp.getSubprojects()) {
            if (parents.contains(sub)) {
                continue;
            }
            ClassPath c = createCP(sub, parents);
            if (c != null) {
                list.add(c);
            }
        }
    }
    if (list.size() > 0) {
        return ClassPathSupport.createProxyClassPath(list.toArray(new ClassPath[list.size()]));
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
static ClassPath createSourcePath (
    Project project,
    Path modulepath,
    Path classpath,
    Path sourcepath,
    boolean isSourcePathExclusive
) {
    if (sourcepath != null && isSourcePathExclusive) {
        return convertToClassPath (project, sourcepath);
    }
    ClassPath cp = convertToSourcePath (project, classpath, true);
    ClassPath modulesSources = convertToSourcePath(project, modules(project, modulepath), true);
    ClassPath sp = convertToClassPath (project, sourcepath);

    ClassPath sourcePath = ClassPathSupport.createProxyClassPath (
        new ClassPath[] {cp, modulesSources, sp}
    );
    return sourcePath;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
/**
 * Create ClassPathInfo for JavaSources only -> (bootPath, classPath, sourcePath)
 * @param roots Source roots
 * @return 
 */
private static ClasspathInfo getClasspathInfo(FileObject[] roots) {
    ClassPath srcPath;
    ClassPath bootPath;

    ClassPath compilePath;

    final ClassPath cpEmpty = ClassPathSupport.createClassPath(new FileObject[0]);
    
    if (roots == null || roots.length == 0) {
        Set<ClassPath> paths = GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE);
        srcPath = ClassPathSupport.createProxyClassPath(paths.toArray(new ClassPath[0]));
        bootPath = JavaPlatform.getDefault().getBootstrapLibraries();
        paths = GlobalPathRegistry.getDefault().getPaths(ClassPath.COMPILE);
        compilePath = ClassPathSupport.createProxyClassPath(paths.toArray(new ClassPath[0]));
    } else {
        srcPath = ClassPathSupport.createClassPath(roots);
        bootPath =
                ClassPath.getClassPath(roots[0], ClassPath.BOOT);
        compilePath =
                ClassPath.getClassPath(roots[0], ClassPath.COMPILE);
    }
    
    return ClasspathInfo.create(bootPath != null ? bootPath : cpEmpty, compilePath != null ? compilePath : cpEmpty, srcPath);
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
@CheckForNull
public static FileObject getFile(
        @NonNull final ElementHandle<TypeElement> toResolve,
        @NonNull final ClasspathInfo cpInfo) {
    FileObject res = SourceUtils.getFile(toResolve, cpInfo);
    if (res == null) {
        final ClassPath cp = ClassPathSupport.createProxyClassPath(
                cpInfo.getClassPath(ClasspathInfo.PathKind.BOOT),
                cpInfo.getClassPath(ClasspathInfo.PathKind.COMPILE));
        res = cp.findResource(String.format(
                "%s.%s",    //NOI18N
                toResolve.getBinaryName().replace('.', '/'),    //NOI18N
                CLASS_EXTENSION));
    }
    return res;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
public ClassPath findClassPath(FileObject file, String type) {
    try {
        FileObject root = findRoot(file);

        if (root == null) {
            return null;
        }
        
        if (ClassPath.BOOT == type) {
            return ClassPathSupport.createClassPath(SourceUtilsTestUtil.getBootClassPath().toArray(new URL[0]));
        }

        if (ClassPath.SOURCE == type) {
            return ClassPathSupport.createClassPath(new FileObject[] {
                root
            });
        }

        if (ClassPath.COMPILE == type) {
            return root2ClassPath.get(root);
        }

        if (ClassPath.EXECUTE == type) {
            return ClassPathSupport.createProxyClassPath(
                    root2ClassPath.get(root),
                    ClassPathSupport.createClassPath(new FileObject[] {
                        root2BuildRoot.get(root)
                    })
                   );
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
private String noJavadocFound() {
    if (handle != null) {
        final List<ClassPath> cps = new ArrayList<>(2);
        ClassPath cp = cpInfo.getClassPath(ClasspathInfo.PathKind.BOOT);
        if (cp != null) {
            cps.add(cp);
        }
        cp = cpInfo.getClassPath(ClasspathInfo.PathKind.COMPILE);
        if (cp != null) {
            cps.add(cp);
        }
        cp = ClassPathSupport.createProxyClassPath(cps.toArray(new ClassPath[cps.size()]));
        String toSearch = SourceUtils.getJVMSignature(handle)[0].replace('.', '/');
        if (handle.getKind() != ElementKind.PACKAGE) {
            toSearch += ".class"; //NOI18N
        }
        final FileObject resource = cp.findResource(toSearch);
        if (resource != null) {
            final FileObject root = cp.findOwnerRoot(resource);
            try {
                final URL rootURL = root.getURL();
                if (JavadocForBinaryQuery.findJavadoc(rootURL).getRoots().length == 0) {
                    FileObject userRoot = FileUtil.getArchiveFile(root);
                    if (userRoot == null) {
                        userRoot = root;
                    }
                    return NbBundle.getMessage(
                            ElementJavadoc.class,
                            "javadoc_content_not_found_attach",
                            rootURL.toExternalForm(),
                            FileUtil.getFileDisplayName(userRoot));
                }
            } catch (FileStateInvalidException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }
    return NbBundle.getMessage(ElementJavadoc.class, "javadoc_content_not_found"); //NOI18N
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
static ClasspathInfo getClassPathInfo() {
    DebuggerEngine engine = DebuggerManager.getDebuggerManager().getCurrentEngine();
    // TODO
    //if (engine != null)
    // Grab the class path from the engine
    
    Set<ClassPath> bootPaths = GlobalPathRegistry.getDefault().getPaths(ClassPath.BOOT);
    Set<ClassPath> classPaths = GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE);
    ClassPath cp = ClassPathSupport.createProxyClassPath(classPaths.toArray(new ClassPath[0]));
    return ClasspathInfo.create(
            ClassPathSupport.createProxyClassPath(bootPaths.toArray(new ClassPath[0])),
            cp, cp);
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
AndroidJavaPlatform(AndroidPlatformInfo pkg, String javaVersion) {
    this.pkg = pkg;
    this.specification = new Specification("j2se", new SpecificationVersion(javaVersion));
    if ("1.8".equals(javaVersion)) {
        URL java8 = FileUtil.urlForArchiveOrDir(FileUtil.normalizeFile(VIRTUALJAVA8ROOT_DIR));
        ClassPath java8ClassPath = ClassPathSupport.createClassPath(new URL[]{java8});
        this.boot = ClassPathSupport.createProxyClassPath(java8ClassPath, GlobalAndroidClassPathRegistry.getClassPath(ClassPath.BOOT, pkg.getBootURLs()));
    } else {
        this.boot = GlobalAndroidClassPathRegistry.getClassPath(ClassPath.BOOT, pkg.getBootURLs());
    }
    this.source = GlobalAndroidClassPathRegistry.getClassPath(ClassPath.SOURCE, pkg.getSrcURLs());
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
@Override
protected ClassPath getClassPath() {
    Project prj = ref.get();
    if(prj != null) {
        ClassPath[] cp = prj.getLookup().lookup(ProjectSourcesClassPathProvider.class).getProjectClassPaths(ClassPath.EXECUTE);
        return ClassPathSupport.createProxyClassPath(cp);
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
public Holder(ClasspathInfo cpInfo) {
    cpInfo.addChangeListener(this);
    LinkedList<ClassPath> cps = new LinkedList<ClassPath>();
    cps.add(cpInfo.getClassPath(PathKind.BOOT));
    cps.add(cpInfo.getClassPath(PathKind.COMPILE));
    cps.add(cpInfo.getClassPath(PathKind.SOURCE));
    compound = ClassPathSupport.createProxyClassPath(cps.toArray(new ClassPath[0]));
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
private static FileObject findRootForFile(final FileObject file, final ClasspathInfo cpInfo) {
    ClassPath cp = ClassPathSupport.createProxyClassPath(
        new ClassPath[] {
            cpInfo.getClassPath(ClasspathInfo.PathKind.SOURCE),
            cpInfo.getClassPath(ClasspathInfo.PathKind.BOOT),
            cpInfo.getClassPath(ClasspathInfo.PathKind.COMPILE),
        });

    FileObject root = cp.findOwnerRoot(file);

    if (root != null) {
        return root;
    }

    for (ClassPath.Entry e : cp.entries()) {
        FileObject[] sourceRoots = SourceForBinaryQuery.findSourceRoots(e.getURL()).getRoots();

        if (sourceRoots.length == 0) continue;

        ClassPath sourcePath = ClassPathSupport.createClassPath(sourceRoots);

        root = sourcePath.findOwnerRoot(file);

        if (root != null) {
            return root;
        }
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
private ClassPath getProjectSourcesClassPath() {
    synchronized (this) {
        if (projectSourcesClassPath == null) {
            projectSourcesClassPath = ClassPathSupport.createProxyClassPath(new ClassPath[] {
                cpProvider.getProjectSourcesClassPath(ClassPath.SOURCE),
                cpProvider.getProjectSourcesClassPath(ClassPath.COMPILE),
            });
        }
        return projectSourcesClassPath;
    }
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
/**
 * Returns a collection of source files in which the passed handles
 * are declared. This tuned up version of {@code SourceUtils.getFile}
 * is necessary as sequential calls to {@code SourceUtils.getFile} are
 * excessively slow.
 *
 * @param handles to find {@link FileObject}s for
 * @param cpInfo classpaths for resolving handle
 * @return collection of {@link FileObject}s
 * @see SourceUtils#getFile(org.netbeans.api.java.source.ElementHandle, org.netbeans.api.java.source.ClasspathInfo) SourceUtils.getFile
 */
public static Collection<FileObject> getFiles(final Collection<ElementHandle<? extends Element>> handles, final ClasspathInfo cpInfo, AtomicBoolean cancel) {
    Parameters.notNull("handle", handles);
    Parameters.notNull("cpInfo", cpInfo);

    List<FileObject> result = new ArrayList<FileObject>(handles.size());
    Map<String, List<ResolvedElementHandle>> handlesPerPackages = new HashMap<String, List<ResolvedElementHandle>>();

    try {
        ClassPath cp = ClassPathSupport.createProxyClassPath(
                new ClassPath[] {
                    cpInfo.getClassPath(ClasspathInfo.PathKind.SOURCE),
                    createClassPath(cpInfo,ClasspathInfo.PathKind.BOOT),
                    createClassPath(cpInfo,ClasspathInfo.PathKind.COMPILE),
                });

        for (ElementHandle<? extends Element> handle : handles) {
            if(cancel != null && cancel.get()) {
                return Collections.<FileObject>emptySet();
            }
            ResolvedElementHandle resolvedEHandle = ResolvedElementHandle.create(handle);
            List<ResolvedElementHandle> l = handlesPerPackages.get(resolvedEHandle.pkgName);
            if (l == null) {
                l = new ArrayList<ResolvedElementHandle>();
                handlesPerPackages.put(resolvedEHandle.pkgName, l);
            }
            l.add(resolvedEHandle);
        }

        for (Map.Entry<String, List<ResolvedElementHandle>> entry : handlesPerPackages.entrySet()) {
            searchFiles(entry.getKey(), entry.getValue(), cp, result);
        }

    } catch (IOException e) {
        Exceptions.printStackTrace(e);
    }
    return result;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
private ClassPath createExecute(ClassPath compile) {
    if (androidProject != null) {
        Variant variant = buildConfig.getCurrentVariant();
        if (variant != null) {
            return ClassPathSupport.createProxyClassPath(compile, ClassPathSupport.createClassPath(
                    FileUtil.urlForArchiveOrDir(FileUtil.normalizeFile(variant.getMainArtifact().getClassesFolder()))));
        }
    }
    return compile;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入方法依赖的package包/类
/**
 * Returns classpath to execute the application merged from all source roots of a project.
 * 
 * @param project
 * @return 
 */
public static ClassPath projectRuntimeModulePath(Project project) {
    List<ClassPath> delegates = new ArrayList<>();
    for (SourceGroup sg : org.netbeans.api.project.ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA)) {
        ClassPath del = ClassPath.getClassPath(sg.getRootFolder(), JavaClassPathConstants.MODULE_EXECUTE_PATH); 
        if (del != null && !del.entries().isEmpty()) {
            delegates.add(del);
        }
    }
    return ClassPathSupport.createProxyClassPath(delegates.toArray(new ClassPath[delegates.size()]));
}