public Set<ElementHandle<TypeElement>> query(ClasspathInfo classpathInfo, String textForQuery, NameKind nameKind, Set<SearchScope> searchScopes) { return classpathInfo.getClassIndex().getDeclaredTypes(textForQuery, nameKind, searchScopes); }
protected final boolean isValidPackage(ClasspathInfo pathInfo, String pkg) { assert pathInfo != null : "ClasspathInfo can not be null"; // the following statement gives us all the packages *starting* with the // first parameter. We have to check for exact matches ourselves. See # 142372 Set<String> pkgSet = pathInfo.getClassIndex().getPackageNames(pkg, true, EnumSet.allOf(ClassIndex.SearchScope.class)); if (pkgSet.size() > 0) { LOG.log(Level.FINEST, "Packages with prefix : {0}", pkg); LOG.log(Level.FINEST, " found : {0}", pkgSet); for (String singlePkg : pkgSet) { if (singlePkg.equals(pkg)){ LOG.log(Level.FINEST, "Exact match found."); return true; } } return false; } else { return false; } }
/** * Returns all types (classes) defined on the given source roots */ private static Set<ElementHandle<TypeElement>> getProjectTypes(FileObject[] roots, JavaSource js) { final Set<ClassIndex.SearchScope> scope = new HashSet<ClassIndex.SearchScope>(); scope.add(ClassIndex.SearchScope.SOURCE); if (js != null) { return js.getClasspathInfo().getClassIndex().getDeclaredTypes("", ClassIndex.NameKind.CASE_INSENSITIVE_PREFIX, scope); // NOI18N } return null; }
@Override protected List<PackageNode> getContainedPackages() { ClassIndex index = cpInfo.getClassIndex(); List<PackageNode> nodes = new ArrayList<PackageNode>(); for (String pkgName : index.getPackageNames(getNodeName() + ".", true, scope)) { // NOI18N nodes.add(new JavaPackageNode(cpInfo, pkgName, this, scope)); } return nodes; }
@Override public void run(CompilationController cc) throws Exception { if (isCancelled()) { return; } cc.toPhase(Phase.ELEMENTS_RESOLVED); ClassIndex ci = cc.getClasspathInfo().getClassIndex(); int index = substitutionOffset; int dotIndex = typedPrefix.lastIndexOf('.'); // NOI18N if (dotIndex != -1) { index += (dotIndex + 1); // NOI18N } addPackages(ci, typedPrefix, index, CompletionProvider.COMPLETION_ALL_QUERY_TYPE); } }, true);
protected List<SelectorNode> prepareChildren(ContainerNode parent) { List<SelectorNode> pkgs = new ArrayList<SelectorNode>(); Project project = parent.getLookup().lookup(Project.class); ClasspathInfo cpInfo = ProjectUtilities.getClasspathInfo(project, subprojects, scope.contains(SearchScope.SOURCE), scope.contains(SearchScope.DEPENDENCIES)); // #170201: A misconfigured(?) project can have no source roots defined, returning NULL as its ClasspathInfo // ignore such a project if (cpInfo != null) { ClassIndex index = cpInfo.getClassIndex(); for (String pkgName : index.getPackageNames("", true, scope)) { // NOI18N pkgs.add(new JavaPackageNode(cpInfo, pkgName, parent, scope)); } Collections.sort(pkgs, PackageNode.COMPARATOR); } return pkgs; } }
private void addIndexListener() { isIndexListenerAdded = true; helper.getClasspathInfo().getClassIndex().addClassIndexListener( new ClassIndexListener() { @Override public void typesAdded(final TypesEvent event) { setDirty(); } @Override public void typesRemoved(final TypesEvent event) { setDirty(); } @Override public void typesChanged(final TypesEvent event) { setDirty(); } @Override public void rootsAdded(RootsEvent event) { setDirty(); } @Override public void rootsRemoved(RootsEvent event) { setDirty(); } private void setDirty() { isDirty.set(true); } }); }
private static FileObject getFileObjectFromClassName(Project p, String qualifiedClassName) throws IOException { FileObject root = MiscUtilities.findSourceRoot(p); 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)); if ( handles == null ){ return null; } for (ElementHandle<TypeElement> handle : handles) { if (qualifiedClassName.equals(handle.getQualifiedName())) { return SourceUtils.getFile(handle, cpInfo); } } return null; }
List<ClassPath> paths = classpathMap.get(fo); ClasspathInfo cpInfo = ClasspathInfo.create(paths.get(0), paths.get(1), paths.get(2)); final ClassIndex classIndex = cpInfo.getClassIndex(); final JavaSource js = JavaSource.create(cpInfo); try {
.create((TypeElement) typeElement); final Set<ElementHandle<TypeElement>> handles = modelImpl .getHelper().getClasspathInfo().getClassIndex() .getElements( handle,
cc.toPhase(Phase.ELEMENTS_RESOLVED); Set<ElementHandle<TypeElement>> declaredTypes = null; declaredTypes = cc.getClasspathInfo().getClassIndex().getDeclaredTypes(typedPrefix, ClassIndex.NameKind.PREFIX, Collections.singleton(ClassIndex.SearchScope.SOURCE));//to have dependencies: EnumSet.allOf(ClassIndex.SearchScope.class)
private Set<TypeElement> doCollectSpecializedImplementors( TypeElement type, List<BindingQualifier> bindings ) { Set<TypeElement> result = new HashSet<TypeElement>(); ElementHandle<TypeElement> handle = ElementHandle.create(type); final Set<ElementHandle<TypeElement>> handles = getHelper() .getClasspathInfo().getClassIndex().getElements( handle, EnumSet.of(SearchKind.IMPLEMENTORS), EnumSet .of(SearchScope.SOURCE, SearchScope.DEPENDENCIES)); if (handles == null) { LOGGER.log(Level.WARNING, "ClassIndex.getElements() was interrupted"); // NOI18N return Collections.emptySet(); } for (ElementHandle<TypeElement> elementHandle : handles) { LOGGER.log(Level.FINE, "found derived element {0}", elementHandle .getQualifiedName()); // NOI18N TypeElement derivedElement = elementHandle.resolve(getHelper(). getCompilationController()); if (derivedElement == null) { continue; } result.add(derivedElement); } return result; }
private static Set<ImportCandidate> findJavaImportCandidates(FileObject fo, String packageName, String missingClass) { final Set<ImportCandidate> candidates = new HashSet<>(); final ClasspathInfo pathInfo = createClasspathInfo(fo); Set<ElementHandle<TypeElement>> typeNames = pathInfo.getClassIndex().getDeclaredTypes( missingClass, NameKind.SIMPLE_NAME, EnumSet.allOf(ClassIndex.SearchScope.class)); for (ElementHandle<TypeElement> typeName : typeNames) { ElementKind kind = typeName.getKind(); // Skip classes within the same package String pkgName = GroovyUtils.stripClassName(typeName.getQualifiedName()); if (packageName == null && pkgName == null) { // Probably both in default package continue; } if (packageName != null && packageName.equals(pkgName)) { continue; } if (kind == ElementKind.CLASS || kind == ElementKind.INTERFACE || kind == ElementKind.ANNOTATION_TYPE) { candidates.add(createImportCandidate(missingClass, typeName.getQualifiedName(), kind)); } } return candidates; }
private static boolean containsAnnotatedJsfResource(CompilationController parameter) { if (jsfResourcesElementHandles == null) { loadJsfResourcesElementsHandles(parameter); } ClassIndex classIndex = parameter.getClasspathInfo().getClassIndex(); for (ElementHandle jsfResourceElementHandle : jsfResourcesElementHandles) { Set<ElementHandle<TypeElement>> elements = classIndex.getElements( jsfResourceElementHandle, EnumSet.of(ClassIndex.SearchKind.TYPE_REFERENCES), EnumSet.of(ClassIndex.SearchScope.SOURCE)); for (ElementHandle<TypeElement> handle : elements) { TypeElement element = handle.resolve(parameter); if (element != null) { List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors(); for (AnnotationMirror annotationMirror : annotationMirrors) { if (ElementHandle.create(annotationMirror.getAnnotationType().asElement()) .equals(jsfResourceElementHandle)) { return true; } } } } } return false; }
private void addPackages(Env env, String fqnPrefix, boolean inPkgStmt) { if (fqnPrefix == null) { fqnPrefix = EMPTY; } String prefix = env.getPrefix() != null ? fqnPrefix + env.getPrefix() : null; for (String pkgName : env.getController().getClasspathInfo().getClassIndex().getPackageNames(fqnPrefix, true, EnumSet.allOf(ClassIndex.SearchScope.class))) { if (startsWith(env, pkgName, prefix) && !Utilities.isExcluded(pkgName + ".")) //NOI18N { results.add(itemFactory.createPackageItem(pkgName, anchorOffset, inPkgStmt)); } } }
return Collections.emptyMap (); final SourceGroup sourceGroup = MidpProjectSupport.getSourceGroup (project); final Set<ElementHandle<TypeElement>> allHandles = info.getClassIndex ().getDeclaredTypes ("", ClassIndex.NameKind.PREFIX, EnumSet.of (ClassIndex.SearchScope.SOURCE, ClassIndex.SearchScope.DEPENDENCIES)); // NOI18N final Map<String, ComponentDescriptor> registry = resolveRegistryMap (project); final HashMap<String, Item> result = new HashMap<String, Item> ();
private void addIndexListener( ) { isIndexListenerAdded = true; final AnnotationModelHelper helper = getModel().getHelper(); helper.getClasspathInfo().getClassIndex().addClassIndexListener( new ClassIndexListener(){
ClassIndex ci = cc.getClasspathInfo().getClassIndex(); int index = substitutionOffset; String packName = typedPrefix;
private void addAllStaticMemberNames(final Env env) { String prefix = env.getPrefix(); if (prefix != null && prefix.length() > 0) { CompilationController controller = env.getController(); Set<? extends Element> excludes = env.getExcludes(); Set<ElementHandle<Element>> excludeHandles = null; if (excludes != null) { excludeHandles = new HashSet<>(excludes.size()); for (Element el : excludes) { excludeHandles.add(ElementHandle.create(el)); } } ClassIndex.NameKind kind = Utilities.isCaseSensitive() ? ClassIndex.NameKind.PREFIX : ClassIndex.NameKind.CASE_INSENSITIVE_PREFIX; Iterable<Symbols> declaredSymbols = controller.getClasspathInfo().getClassIndex().getDeclaredSymbols(prefix, kind, EnumSet.allOf(ClassIndex.SearchScope.class)); for (Symbols symbols : declaredSymbols) { if (Utilities.isExcluded(symbols.getEnclosingType().getQualifiedName()) || excludeHandles != null && excludeHandles.contains(symbols.getEnclosingType()) || isAnnonInner(symbols.getEnclosingType())) { continue; } for (String name : symbols.getSymbols()) { if (!Utilities.isExcludeMethods() || !Utilities.isExcluded(symbols.getEnclosingType().getQualifiedName() + '.' + name)) { results.add(itemFactory.createStaticMemberItem(symbols.getEnclosingType(), name, anchorOffset, env.addSemicolon(), env.getReferencesCount(), controller.getSnapshot().getSource())); } } } } }
ClassIndex ci = cc.getClasspathInfo().getClassIndex();