import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public ClassPath findClassPath(FileObject file, String type) {
    if(ClassPath.SOURCE.equals(type)){
        return this.classPath;
    }
    if (ClassPath.COMPILE.equals(type)){
        try {
            URL eclipselinkJarUrl = Class.forName("javax.persistence.EntityManager").getProtectionDomain().getCodeSource().getLocation();
            URL[] urls = new URL[]{FileUtil.getArchiveRoot(eclipselinkJarUrl)};
            return ClassPathSupport.createClassPath(urls);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    } 
    if (ClassPath.BOOT.equals(type)){
        return JavaPlatformManager.getDefault().getDefaultPlatform().getBootstrapLibraries();
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public String getSourceLevel(org.openide.filesystems.FileObject javaFile) {        
    Library ll = this.isLastUsed (javaFile);
    if (ll != null) {
        return getSourceLevel (ll);
    }
    for (LibraryManager mgr : LibraryManager.getOpenManagers()) {
        for (Library lib : mgr.getLibraries()) {
            if (!lib.getType().equals(J2SELibraryTypeProvider.LIBRARY_TYPE)) {
                continue;
            }
            List<URL> sourceRoots = lib.getContent(J2SELibraryTypeProvider.VOLUME_TYPE_SRC);
            if (sourceRoots.isEmpty()) {
                continue;
            }
            ClassPath cp = ClassPathSupport.createClassPath(sourceRoots.toArray(new URL[sourceRoots.size()]));
            FileObject root = cp.findOwnerRoot(javaFile);
            if (root != null) {
                setLastUsedRoot(root, lib);
                return getSourceLevel(lib);
            }
        }
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
/**
 * This implementation simply reads and parses `java.class.path' property and creates a ClassPath
 * out of it.
 * @return  ClassPath that represents contents of system property java.class.path.
 */
@Override
public ClassPath getStandardLibraries() {
    synchronized (this) {
        ClassPath cp = (standardLibs == null ? null : standardLibs.get());
        if (cp != null)
            return cp;
        final String pathSpec = getSystemProperties().get(SYSPROP_JAVA_CLASS_PATH);
        if (pathSpec == null) {
            cp = ClassPathSupport.createClassPath(new URL[0]);
        }
        else {
            cp = Util.createClassPath (pathSpec);
        }
        standardLibs = new SoftReference<>(cp);
        return cp;
    }
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
private String classToSourceURL (FileObject fo) {
    try {
        ClassPath cp = ClassPath.getClassPath (fo, ClassPath.EXECUTE);
        FileObject root = cp.findOwnerRoot (fo);
        String resourceName = cp.getResourceName (fo, '/', false);
        if (resourceName == null) {
            getProject().log("Can not find classpath resource for "+fo+", skipping...", Project.MSG_ERR);
            return null;
        }
        int i = resourceName.indexOf ('$');
        if (i > 0)
            resourceName = resourceName.substring (0, i);
        FileObject[] sRoots = SourceForBinaryQuery.findSourceRoots 
            (root.getURL ()).getRoots ();
        ClassPath sourcePath = ClassPathSupport.createClassPath (sRoots);
        FileObject rfo = sourcePath.findResource (resourceName + ".java");
        if (rfo == null) return null;
        return rfo.getURL ().toExternalForm ();
    } catch (FileStateInvalidException ex) {
        ex.printStackTrace ();
        return null;
    }
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
@Override
protected List<PathResourceImplementation> createResources() {
    ArrayList<PathResourceImplementation> result = new ArrayList<> ();
            boolean[] includeJDK = { true };
            boolean[] includeFX = { false };
            result.addAll(ecpImpl.getResources(includeJDK, includeFX));
            lastHintValue = project.getAuxProps().get(Constants.HINT_JDK_PLATFORM, true);
            if (includeJDK[0]) {
                JavaPlatform pat = findActivePlatform();
                boolean hasFx = false;
                for (ClassPath.Entry entry : pat.getBootstrapLibraries().entries()) {
                    if (entry.getURL().getPath().endsWith("/jfxrt.jar!/")) {
                        hasFx = true;
                    }
                    result.add(ClassPathSupport.createResource(entry.getURL()));
                }
                if (includeFX[0] && !hasFx) {
                    PathResourceImplementation fxcp = createFxCPImpl(pat);
                    if (fxcp != null) {
                        result.add(fxcp);
                    }
                }
                result.addAll(nbPlatformJavaFxCp(project, pat));
            }
    return result;
        }
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
@CheckForNull
private static FileObject findOwnerRoot(
    @NonNull final String className,
    @NonNull final String[] extensions,
    @NonNull final ClassPath... binCps) {
    final String binaryResource = FileObjects.convertPackage2Folder(className);
    final ClassPath merged = ClassPathSupport.createProxyClassPath(binCps);
    for (String ext : extensions) {
        final FileObject res = merged.findResource(String.format(
                "%s.%s",    //NOI18N
                binaryResource,
                ext));
        if (res != null) {
            return merged.findOwnerRoot(res);
        }
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
/**
     * Creates boot {@link ClassPath} for platform the test is running on,
     * it uses the sun.boot.class.path property to find out the boot path roots.
     * @return ClassPath
     * @throws java.io.IOException when boot path property contains non valid path
     */
    public static ClassPath createBootClassPath() throws IOException {
        String bootPath = System.getProperty("sun.boot.class.path");
        String[] paths = bootPath.split(File.pathSeparator);
        List<URL> roots = new ArrayList<>(paths.length);
        for (String path : paths) {
            File f = new File(path);
            if (!f.exists()) {
                continue;
            }
            URL url = Utilities.toURI(f).toURL();
            if (FileUtil.isArchiveFile(url)) {
                url = FileUtil.getArchiveRoot(url);
            }
            roots.add(url);
//            System.out.println(url);
        }
//        System.out.println("-----------");
        return ClassPathSupport.createClassPath(roots.toArray(new URL[roots.size()]));
    }
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
/**
 * Copied from JUnit module implementation in 4.1 and modified
 */
private static FileObject findUnitTestInTestRoot(ClassPath cp, FileObject selectedFO, URL testRoot) {
    ClassPath testClassPath = null;

    if (testRoot == null) { //no tests, use sources instead
        testClassPath = cp;
    } else {
        try {
            List<PathResourceImplementation> cpItems = new ArrayList<PathResourceImplementation>();
            cpItems.add(ClassPathSupport.createResource(testRoot));
            testClassPath = ClassPathSupport.createClassPath(cpItems);
        } catch (IllegalArgumentException ex) {
            ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ex);
            testClassPath = cp;
        }
    }

    String testName = getTestName(cp, selectedFO);

    return testClassPath.findResource(testName + ".java"); // NOI18N
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public ClassPath findClassPath(FileObject file, String type) {
    if(ClassPath.SOURCE.equals(type)){
        return this.classPath;
    }
    if (ClassPath.COMPILE.equals(type)){
        try {
            URL eclipselinkJarUrl = Class.forName("javax.persistence.EntityManager").getProtectionDomain().getCodeSource().getLocation();
            return ClassPathSupport.createClassPath(new URL[]{FileUtil.getArchiveRoot(eclipselinkJarUrl)});
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
    if (ClassPath.BOOT.equals(type)){
        return JavaPlatformManager.getDefault().getDefaultPlatform().getBootstrapLibraries();
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public static ClassPath projecRuntimeClassPath(Project project) {
    if (project == null) {
        return null;
    }
    boolean modular = isModularProject(project);
    List<ClassPath> delegates = new ArrayList<>();
    for (SourceGroup sg : org.netbeans.api.project.ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA)) {
        if (!isNormalRoot(sg)) {
            continue;
        }
        ClassPath del; 
        if (modular) {
            del = ClassPath.getClassPath(sg.getRootFolder(), JavaClassPathConstants.MODULE_EXECUTE_CLASS_PATH);
        } else {
            del = ClassPath.getClassPath(sg.getRootFolder(), ClassPath.EXECUTE); 
        }
        if (del != null && !del.entries().isEmpty()) {
            delegates.add(del);
        }
    }
    return ClassPathSupport.createProxyClassPath(delegates.toArray(new ClassPath[delegates.size()]));
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public ClassPath findClassPath(FileObject file, String type) {
    try {
    if (ClassPath.BOOT == type) {
        // XXX simpler to use JavaPlatformManager.getDefault().getDefaultPlatform().getBootstrapLibraries()
        return ClassPathSupport.createClassPath(getBootClassPath().toArray(new URL[0]));
    }

    if (ClassPath.SOURCE == type) {
        return sourcePath;
    }

    if (ClassPath.COMPILE == type) {
        return compileClassPath;
    }

    if (ClassPath.EXECUTE == type) {
        return ClassPathSupport.createClassPath(new FileObject[] {
            buildRoot
        });
    }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
private static ClassPath getJavacApiJarClasspath() {
    Reference<ClassPath> r = javacApiClasspath;
    ClassPath res = r.get();
    if (res != null) {
        return res;
    }
    if (r == NONE) {
        return null;
    }
    CodeSource codeSource = Modifier.class.getProtectionDomain().getCodeSource();
    URL javacApiJar = codeSource != null ? codeSource.getLocation() : null;
    if (javacApiJar != null) {
        Logger.getLogger(DeclarativeHintsParser.class.getName()).log(Level.FINE, "javacApiJar={0}", javacApiJar);
        File aj = FileUtil.archiveOrDirForURL(javacApiJar);
        if (aj != null) {
            res = ClassPathSupport.createClassPath(FileUtil.urlForArchiveOrDir(aj));
            javacApiClasspath = new WeakReference<>(res);
            return res;
        }
    }
    javacApiClasspath = NONE;
    return null;
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public void testNBResLocURL() throws Exception {
    Map<String, String> files = new HashMap<String, String>();
    files.put("org/test/x.txt", "stuff");
    files.put("org/test/resources/y.txt", "more stuff");
    Layer orig = new Layer("<file name='x' url='nbres:/org/test/x.txt'/><file name='y' url='nbresloc:/org/test/resources/y.txt'/>", files);
    FileObject orgTest = FileUtil.createFolder(new File(orig.folder, "org/test"));
    FileObject lf = orig.f.copy(orgTest, "layer", "xml");
    SavableTreeEditorCookie cookie = LayerUtils.cookieForFile(lf);
    FileSystem fs = new WritableXMLFileSystem(lf.toURL(), cookie,
            ClassPathSupport.createClassPath(new FileObject[] { FileUtil.toFileObject(orig.folder) } ));
    FileObject x = fs.findResource("x");
    assertNotNull(x);
    assertTrue(x.isData());
    assertEquals(5L, x.getSize());
    assertEquals("stuff", x.asText("UTF-8"));

    FileObject y = fs.findResource("y");
    assertNotNull(y);
    assertTrue(y.isData());
    assertEquals(10L, y.getSize());
    assertEquals("more stuff", y.asText("UTF-8"));
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
@RandomlyFails
    public void testBinaryIndexers() throws Exception {
        final TestHandler handler = new TestHandler();
        final Logger logger = Logger.getLogger(RepositoryUpdater.class.getName()+".tests");
        logger.setLevel (Level.FINEST);
        logger.addHandler(handler);

        binIndexerFactory.indexer.setExpectedRoots(bootRoot2.toURL(), bootRoot3.toURL());
//        jarIndexerFactory.indexer.setExpectedRoots(bootRoot3.getURL());
        ClassPath cp = ClassPathSupport.createClassPath(new FileObject[] {bootRoot2, bootRoot3});
        globalPathRegistry_register(PLATFORM,new ClassPath[] {cp});
        assertTrue(handler.await());
        assertEquals(2, handler.getBinaries().size());
//        assertEquals(1, jarIndexerFactory.indexer.getCount());
        assertEquals(2, binIndexerFactory.indexer.getCount());
    }
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public void testDeadLock() throws Exception{
    List<PathResourceImplementation> resources = Collections.<PathResourceImplementation>emptyList();
    final ReentrantLock lock = new ReentrantLock (false);
    final CountDownLatch signal = new CountDownLatch (1);
    final ClassPath cp = ClassPathFactory.createClassPath(ClassPathSupport.createProxyClassPathImplementation(new ClassPathImplementation[] {new LockClassPathImplementation (resources,lock, signal)}));
    lock.lock();
    final ExecutorService es = Executors.newSingleThreadExecutor();        
    try {
        es.submit(new Runnable () {
            public void run () {
                cp.entries();
            }
        });
        signal.await();
        cp.entries();
    } finally {
        es.shutdownNow();
    }
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
/**
 * Waits for the end of the initial scan, this helper method 
 * is designed for tests which require to wait for end of initial scan.
 * @throws InterruptedException is thrown when the waiting thread is interrupted.
 * @deprecated use {@link JavaSource#runWhenScanFinished}
 */
public static void waitScanFinished () throws InterruptedException {
    try {
        class T extends UserTask implements ClasspathInfoProvider {
            private final ClassPath EMPTY_PATH = ClassPathSupport.createClassPath(new URL[0]);
            private final ClasspathInfo cpinfo = ClasspathInfo.create(EMPTY_PATH, EMPTY_PATH, EMPTY_PATH);
            @Override
            public void run(ResultIterator resultIterator) throws Exception {
                // no-op
            }

            @Override
            public ClasspathInfo getClasspathInfo() {
                return cpinfo;
            }
        }
        Future<Void> f = ParserManager.parseWhenScanFinished(JavacParser.MIME_TYPE, new T());
        if (!f.isDone()) {
            f.get();
        }
    } catch (Exception ex) {
    }
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
private static FileObject findUnitTestInTestRoot(ClassPath cp, FileObject selectedFO, URL testRoot) {
    ClassPath testClassPath = null;
    if (testRoot == null) { //no tests, use sources instead
        testClassPath = cp;
    } else {
        try {
            List<PathResourceImplementation> cpItems
                    = new ArrayList<PathResourceImplementation>();
            cpItems.add(ClassPathSupport.createResource(testRoot));
            testClassPath = ClassPathSupport.createClassPath(cpItems);
        } catch (IllegalArgumentException ex) {
            ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ex);
            testClassPath = cp; 
        }
    }
    String testName = getTestName(cp, selectedFO);
    return testClassPath.findResource(testName+".java");
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
protected void projectOpened() {
    ClassPath cp = ClassPathSupport.createClassPath(prj);
    GlobalPathRegistry.getDefault().register(ClassPath.SOURCE, new ClassPath[] { cp });

    if (toWaitOn != null) {
        try {
            toWaitOn.await();
        } catch (InterruptedException ex) {
            throw new IllegalStateException(ex);
        }
    }
    opened++;
    toOpen.countDown();
    result &= IndexingManager.getDefault().isIndexing();
    assertTrue(result);
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
/**
 * Test that unknown source roots are registered in the scannedRoots2Dependencies with EMPTY_DEPS
 * and when the unknown root registers it's changed to regular dependencies.
 * When the root is unregistered it's removed from scannedRoots2Dependencies
 *
 * The test was also extended to test Issue 196985. Unknown root which becomes known was lost
 * @throws Exception
 */
public void testIndexManagerRefreshIndexListensOnChanges_And_Issue196985() throws Exception {
    final File _wd = this.getWorkDir();
    final FileObject wd = FileUtil.toFileObject(_wd);
    final FileObject refreshedRoot = wd.createFolder("refreshedRoot");
    final RepositoryUpdater ru = RepositoryUpdater.getDefault();
    assertNotNull(refreshedRoot);
    assertFalse (ru.getScannedRoots2Dependencies().containsKey(refreshedRoot.toURL()));
    IndexingManager.getDefault().refreshIndexAndWait(refreshedRoot.toURL(), Collections.<URL>emptyList());
    assertSame(RepositoryUpdater.UNKNOWN_ROOT, ru.getScannedRoots2Dependencies().get(refreshedRoot.toURL()));
    //Register the root => EMPTY_DEPS changes to regular deps
    final TestHandler handler = new TestHandler();
    final Logger logger = Logger.getLogger(RepositoryUpdater.class.getName()+".tests");
    logger.setLevel (Level.FINEST);
    logger.addHandler(handler);
    final ClassPath cp = ClassPathSupport.createClassPath(refreshedRoot);
    handler.reset(RepositoryUpdaterTest.TestHandler.Type.ROOTS_WORK_FINISHED);
    globalPathRegistry_register(SOURCES, new ClassPath[]{cp});
    handler.await();
    assertNotNull(ru.getScannedRoots2Dependencies().get(refreshedRoot.toURL()));
    assertNotSame(RepositoryUpdater.UNKNOWN_ROOT, ru.getScannedRoots2Dependencies().get(refreshedRoot.toURL()));
    handler.reset(RepositoryUpdaterTest.TestHandler.Type.ROOTS_WORK_FINISHED);
    globalPathRegistry_unregister(SOURCES, new ClassPath[]{cp});
    handler.await();
    assertFalse(ru.getScannedRoots2Dependencies().containsKey(refreshedRoot.toURL()));
}
 

import org.netbeans.spi.java.classpath.support.ClassPathSupport; //导入依赖的package包/类
public void testGetFileForInputWithCachingArchive() throws  Exception {
    final File wd = getWorkDir();
    final File archiveFile = new File (wd, "src.zip");
    final ZipOutputStream out = new ZipOutputStream(new FileOutputStream(archiveFile));
    try {
        out.putNextEntry(new ZipEntry("org/me/resources/test.txt"));
        out.write("test".getBytes());
    } finally {
        out.close();
    }
    final URL archiveRoot = FileUtil.getArchiveRoot(Utilities.toURI(archiveFile).toURL());
    final URI expectedURI = new URL (archiveRoot.toExternalForm()+"org/me/resources/test.txt").toURI();
    doTestGetFileForInput(ClassPathSupport.createClassPath(archiveRoot),
    Arrays.asList(
        Pair.<Pair<String,String>,URI>of(Pair.<String,String>of("","org/me/resources/test.txt"), expectedURI),
        Pair.<Pair<String,String>,URI>of(Pair.<String,String>of("org.me","resources/test.txt"), expectedURI),
        Pair.<Pair<String,String>,URI>of(Pair.<String,String>of("org.me","resources/doesnotexist.txt"), null)
    ));

}