Java ClasspathInfo类代码示例

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public void testGetFirstTypeArgument() throws Exception {
    ClasspathInfo cpi = ClasspathInfo.create(srcFO);
    final AnnotationModelHelper helper = AnnotationModelHelper.create(cpi);
    helper.runJavaSourceTask(new Runnable() {
        public void run() {
            Elements elements = helper.getCompilationController().getElements();
            Types types = helper.getCompilationController().getTypes();
            TypeElement typeElement = elements.getTypeElement("java.util.Collection");
            // Collection<E>
            assertNull(EntityMappingsUtilities.getFirstTypeArgument(typeElement.asType()));
            // Collection
            assertNull(EntityMappingsUtilities.getFirstTypeArgument(types.erasure(typeElement.asType())));
            // Collection<String>
            TypeMirror stringType = elements.getTypeElement("java.lang.String").asType();
            TypeElement argTypeElement = EntityMappingsUtilities.getFirstTypeArgument(types.getDeclaredType(typeElement, stringType));
            assertTrue(argTypeElement.getQualifiedName().contentEquals("java.lang.String"));
        }
    });
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public static JavaSource getJavaSource(Document doc) {
    FileObject fileObject = NbEditorUtilities.getFileObject(doc);
    if (fileObject == null) {
        return null;
    }
    Project project = FileOwnerQuery.getOwner(fileObject);
    if (project == null) {
        return null;
    }
    // XXX this only works correctly with projects with a single sourcepath,
    // but we don't plan to support another kind of projects anyway (what about Maven?).
    // mkleint: Maven has just one sourceroot for java sources, the config files are placed under
    // different source root though. JavaProjectConstants.SOURCES_TYPE_RESOURCES
    SourceGroup[] sourceGroups = ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    for (SourceGroup sourceGroup : sourceGroups) {
        return JavaSource.create(ClasspathInfo.create(sourceGroup.getRootFolder()));
    }
    return null;
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public static Set<TypeElement> findImplementorsResolved(final ClasspathInfo cpInfo, final ElementHandle<TypeElement> baseType) {
    final Set<TypeElement> implementors = new HashSet<TypeElement>();
    final Set<ElementHandle<TypeElement>> implHandles = findImplementors(cpInfo, baseType);
    
    if (!implHandles.isEmpty()) {
        ParsingUtils.invokeScanSensitiveTask(cpInfo, new ScanSensitiveTask<CompilationController>(true) {
            public void run(CompilationController controller)
                    throws Exception {
                if (controller.toPhase(Phase.ELEMENTS_RESOLVED).compareTo(Phase.ELEMENTS_RESOLVED) < 0) {
                    return;
                }

                for(ElementHandle<TypeElement> eh : implHandles) {
                    implementors.add(eh.resolve(controller));
                }

            }
        });
    }

    return implementors;
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public void testGoToAnnonymousInnerClass() throws Exception {
    final boolean[] wasCalled = new boolean[1];

    performTest("package test; public class Test {public void test() {new Runnable() {public void run(){}};} }", 61, new OrigUiUtilsCaller() {
        public void open(FileObject fo, int pos) {
            fail("Should not be called.");
        }
        public void beep() {
            fail("Should not be called.");
        }
        public void open(ClasspathInfo info, Element el) {
            assertEquals(ElementKind.INTERFACE, el.getKind());
            assertEquals("java.lang.Runnable", ((TypeElement) el).getQualifiedName().toString());
            wasCalled[0] = true;
        }
    }, false);

    assertTrue(wasCalled[0]);
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public static FileObject getFileObjectFromClassName(String qualifiedClassName, Project project) throws IOException {
    FileObject root = findSourceRoot(project);
    ClasspathInfo cpInfo = ClasspathInfo.create(root);
    ClassIndex ci = cpInfo.getClassIndex();
    int beginIndex = qualifiedClassName.lastIndexOf('.')+1;
    String simple = qualifiedClassName.substring(beginIndex);
    Set<ElementHandle<TypeElement>> handles = ci.getDeclaredTypes(
            simple, ClassIndex.NameKind.SIMPLE_NAME, 
            Collections.singleton(ClassIndex.SearchScope.SOURCE));
    for (ElementHandle<TypeElement> handle : handles) {
        if (qualifiedClassName.equals(handle.getQualifiedName())) {
            return SourceUtils.getFile(handle, cpInfo);
        }
    }
    return null;
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public void testGoToStaticImport() throws Exception {
    final boolean[] wasCalled = new boolean[1];
    String code = "package test; import static java.awt.Color.BLACK; public class Test {}";

    performTest(code, code.indexOf("BLACK") + 1, new OrigUiUtilsCaller() {
        public void open(FileObject fo, int pos) {
            fail("Should not be called.");
        }
        public void beep() {
            fail("Should not be called.");
        }
        public void open(ClasspathInfo info, Element el) {
            assertEquals(ElementKind.FIELD, el.getKind());
            assertEquals("java.awt.Color.BLACK",
                    ((TypeElement) el.getEnclosingElement()).getQualifiedName().toString() + '.' + el);
            wasCalled[0] = true;
        }
    }, false);

    assertTrue(wasCalled[0]);
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public static MethodCustomizer operationMethod(String title, MethodModel method, ClasspathInfo cpInfo, Collection<MethodModel> existingMethods) {
    return new MethodCustomizer(
            title,
            method,
            cpInfo,
            true, // doesn't matter? interfaces selections is disabled
            true, // doesn't matter? interfaces selections is disabled
            true, // doesn't matter? interfaces selections is disabled
            true, // doesn't matter? interfaces selections is disabled
            true,  // return type
            null,  // EJB QL
            false, // finder cardinality
            true,  // exceptions
            false, // interfaces
            null,  // prefix
            existingMethods
            );
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
private static boolean isClassEjb31Bean(WorkingCopy wc, TypeElement srcClass) {
    ClassPath cp = wc.getClasspathInfo().getClassPath(ClasspathInfo.PathKind.COMPILE);
    if (cp == null || cp.findResource("javax/ejb/embeddable/EJBContainer.class") == null) {
        // if EJBContainer class is not available on classpath then it is not EJB 3.1
        return false;
    }
    List<? extends AnnotationMirror> annotations = wc.getElements().getAllAnnotationMirrors(srcClass);
    for (AnnotationMirror am : annotations) {
        String annotation = ((TypeElement)am.getAnnotationType().asElement()).getQualifiedName().toString();
        if (annotation.equals("javax.ejb.Singleton") || // NOI18N
            annotation.equals("javax.ejb.Stateless") || // NOI18N
            annotation.equals("javax.ejb.Stateful")) { // NOI18N
            // class is an EJB
            return true;
        }
    }
    return false;
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public void testInterrupted() throws Exception {
    IndexingManager.getDefault().refreshIndexAndWait(srcFO.getURL(), null);
    ClasspathInfo cpi = ClasspathInfo.create(srcFO);
    final AnnotationModelHelper helper = AnnotationModelHelper.create(cpi);
    helper.runJavaSourceTask(new Runnable() {
        public void run() {
            // first checking that the manager does not (for any reason) initialize temporarily
            ObjectProvider<PersistentObject> provider = new InterruptibleObjectProviderImpl(false);
            PersistentObjectManager<PersistentObject> manager = helper.createPersistentObjectManager(provider);
            manager.getObjects();
            assertFalse(manager.temporary);
            // now checking that the manager initializes temporarily when ObjectProvider.createInitialObjects throws InterruptedException
            provider = new InterruptibleObjectProviderImpl(true);
            manager = helper.createPersistentObjectManager(provider);
            manager.getObjects();
            assertTrue(manager.temporary);
        }
    });
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public void testGoToClass() throws Exception {
    final boolean[] wasCalled = new boolean[1];

    performTest("package test; public class Test { public static void main(String[] args) {TT tt} } class TT { }", 75, new OrigUiUtilsCaller() {
        public void open(FileObject fo, int pos) {
            assertTrue(source == fo);
            assertEquals(83, pos);
            wasCalled[0] = true;
        }
        public void beep() {
            fail("Should not be called.");
        }
        public void open(ClasspathInfo info, Element el) {
            fail("Should not be called.");
        }
    }, false);

    assertTrue(wasCalled[0]);
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
/**
 * Completes an 'absolute' pathname (anchored at the root of the classpath)
 */
private void completeFromRoots() {
    String folderName;
    String fileMatch;
    int lastSlash = valPrefix.lastIndexOf('/');
    if (lastSlash == 0) {
        folderName = "";
        fileMatch = valPrefix.substring(1);
    } else {
        folderName = valPrefix.substring(1, lastSlash);
        fileMatch = valPrefix.substring(lastSlash + 1);
    }

    Set<String> names = new HashSet<String>();
    List<FileObject> files = new ArrayList<FileObject>();

    collectFromClasspath(context.getClasspathInfo().getClassPath(ClasspathInfo.PathKind.SOURCE), 
            folderName, files, names, fileMatch, extMatch);
    collectFromClasspath(context.getClasspathInfo().getClassPath(ClasspathInfo.PathKind.COMPILE), 
            folderName, files, names, fileMatch, extMatch);
    
    toCompletionItems(folderName, files);
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
private static Collection<String> getPackages(FileObject root) {
    ClasspathInfo cpi = ClasspathInfo.create(root);
    // create CPI from just the single source root, to avoid packages from other
    // modules
    ClasspathInfo rootCpi = new ClasspathInfo.Builder(
            cpi.getClassPath(PathKind.BOOT)).
            setClassPath(cpi.getClassPath(PathKind.COMPILE)).
            setModuleSourcePath(cpi.getClassPath(PathKind.MODULE_SOURCE)).
            setModuleCompilePath(cpi.getClassPath(PathKind.MODULE_COMPILE)).
            setSourcePath(
                ClassPathSupport.createClassPath(root)
            ).build();
    
    Collection<String> pkgs = new HashSet<>(rootCpi.getClassIndex().getPackageNames("", false, 
            Collections.singleton(SearchScope.SOURCE)));
    pkgs.remove(""); // NOI18N
    return pkgs;
}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
/**
 * Get {@link ClasspathInfo} for project. In most cases, you are interested in {@link ClassIndex} you can retrieve using
 * {@link ClasspathInfo#getClassIndex() }.
 * If you need to owner project of some file, use {@link FileOwnerQuery}.
 * @param project What project should I use to determine classpath?
 * @return classpath for project that contains {@link ClassPath#BOOT}, {@link ClassPath#COMPILE}, and {@link ClassPath#SOURCE}
 */
protected final ClasspathInfo getClasspathInfo(Project project) {
    ClassPathProvider cpp = project.getLookup().lookup(ClassPathProvider.class);
    assert cpp != null;
    
    // FIXME: should I use sources of project? TEST!!! What about multiple sources?
    Sources sources = project.getLookup().lookup(Sources.class);
    assert sources != null;
    
    SourceGroup[] groups = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    assert groups.length != 0;
    SourceGroup group = groups[0];
    
    ClassPath bootPath = cpp.findClassPath(group.getRootFolder(), ClassPath.BOOT);
    ClassPath compilePath = cpp.findClassPath(group.getRootFolder(), ClassPath.COMPILE);
    ClassPath srcPath = cpp.findClassPath(group.getRootFolder(), ClassPath.SOURCE);

    return ClasspathInfo.create(bootPath, compilePath, srcPath);

}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
private void browseButtonActionPerformed(ActionEvent evt) {
    SwingUtilities.invokeLater(new Runnable() {

        @Override
        public void run() {
            final ElementHandle<TypeElement> handle = TypeElementFinder.find(null, new TypeElementFinder.Customizer() {

                @Override
                public Set<ElementHandle<TypeElement>> query(ClasspathInfo classpathInfo, String textForQuery, NameKind nameKind, Set<SearchScope> searchScopes) {
                    return classpathInfo.getClassIndex().getDeclaredTypes(textForQuery, nameKind, searchScopes);
                }

                @Override
                public boolean accept(ElementHandle<TypeElement> typeHandle) {
                    return true;
                }
            });

            if (handle != null) {
                txtClassName.setText(handle.getQualifiedName());
            }
        }
    });

}
 

import org.netbeans.api.java.source.ClasspathInfo; //导入依赖的package包/类
public void testGoToSuperMethod2() throws Exception {
    //try to go to "super" in super.methodInParent():
    final boolean[] wasCalled = new boolean[1];

    performTest("package test; public class Test extends Base { public void test() {super.methodInParent();} } class Base {public void methodInParent() {}}", 70, new OrigUiUtilsCaller() {
        public void open(FileObject fo, int pos) {
            fail("Should not be called.");
        }
        public void beep() {
            wasCalled[0] = true;
        }
        public void open(ClasspathInfo info, Element el) {
            fail("Should not be called.");
        }
    }, false);

    assertTrue(wasCalled[0]);
}