com.intellij.util.indexing.IdFilter Java Examples

@Nonnull
private static Set<VirtualFile> getVirtualFilesByNameIgnoringCase(@Nonnull final String name, @Nonnull final GlobalSearchScope scope, @Nonnull Project project, @Nullable final IdFilter idFilter) {
  final Set<String> keys = new THashSet<>();
  FileNameIndexService fileNameIndexService = getService();
  fileNameIndexService.processAllFileNames(value -> {
    if (name.equalsIgnoreCase(value)) {
      keys.add(value);
    }
    return true;
  }, scope, idFilter);

  // values accessed outside of processAllKeys
  final Set<VirtualFile> files = new THashSet<>();
  for (String each : keys) {
    files.addAll(fileNameIndexService.getVirtualFilesByName(project, each, scope, idFilter));
  }
  return files;
}
 

@Override
public void processElementsWithName(
		@Nonnull String name, @Nonnull Processor<NavigationItem> navigationItemProcessor, @Nonnull FindSymbolParameters findSymbolParameters)
{
	Project project = findSymbolParameters.getProject();
	IdFilter idFilter = findSymbolParameters.getIdFilter();
	GlobalSearchScope searchScope = findSymbolParameters.getSearchScope();

	StubIndex.getInstance().processElements(CSharpIndexKeys.METHOD_INDEX, name, project, searchScope, idFilter,
			DotNetLikeMethodDeclaration.class, (Processor) navigationItemProcessor);
	StubIndex.getInstance().processElements(CSharpIndexKeys.EVENT_INDEX, name, project, searchScope, idFilter,
			DotNetEventDeclaration.class,  (Processor) navigationItemProcessor);
	StubIndex.getInstance().processElements(CSharpIndexKeys.PROPERTY_INDEX, name, project, searchScope, idFilter,
			DotNetPropertyDeclaration.class, (Processor) navigationItemProcessor);
	StubIndex.getInstance().processElements(CSharpIndexKeys.FIELD_INDEX, name, project, searchScope, idFilter,
			DotNetFieldDeclaration.class, (Processor) navigationItemProcessor);
}
 

public static boolean processFilesByName(@Nonnull final String name,
                                         boolean directories,
                                         @Nonnull Processor<? super PsiFileSystemItem> processor,
                                         @Nonnull GlobalSearchScope scope,
                                         @Nonnull Project project,
                                         @Nullable IdFilter idFilter) {
  return processFilesByName(name, directories, true, processor, scope, project, idFilter);
}
 

@Override
public void processNames(@Nonnull final Processor<String> processor, @Nonnull GlobalSearchScope scope, IdFilter filter) {
  long started = System.currentTimeMillis();
  FilenameIndex.processAllFileNames(processor, scope, filter);
  if (LOG.isDebugEnabled()) {
    LOG.debug("All names retrieved:" + (System.currentTimeMillis() - started));
  }
}
 

@Nonnull
private static FindSymbolParameters createParameters(@Nonnull ChooseByNameViewModel base, @Nonnull String pattern, boolean everywhere) {
  ChooseByNameModel model = base.getModel();
  IdFilter idFilter = model instanceof ContributorsBasedGotoByModel ? ((ContributorsBasedGotoByModel)model).getIdFilter(everywhere) : null;
  GlobalSearchScope searchScope = FindSymbolParameters.searchScopeFor(base.getProject(), everywhere);
  return new FindSymbolParameters(pattern, getNamePattern(base, pattern), searchScope, idFilter);
}
 

@Nonnull
@Override
public Collection<VirtualFile> getVirtualFilesByName(Project project, @Nonnull String name, @Nonnull GlobalSearchScope scope, IdFilter filter) {
  Set<VirtualFile> files = new THashSet<>();
  myIndex.processValues(FilenameIndexImpl.NAME, name, null, (file, value) -> {
    files.add(file);
    return true;
  }, scope, filter);
  return files;
}
 

@Nonnull
public static <Key, Psi extends PsiElement> Collection<Psi> getElements(@Nonnull StubIndexKey<Key, Psi> indexKey,
                                                                        @Nonnull Key key,
                                                                        @Nonnull final Project project,
                                                                        @Nullable final GlobalSearchScope scope,
                                                                        @Nullable IdFilter idFilter,
                                                                        @Nonnull Class<Psi> requiredClass) {
  final List<Psi> result = new SmartList<>();
  Processor<Psi> processor = Processors.cancelableCollectProcessor(result);
  getInstance().processElements(indexKey, key, project, scope, idFilter, requiredClass, processor);
  return result;
}
 

public <Key, Psi extends PsiElement> boolean processElements(@Nonnull StubIndexKey<Key, Psi> indexKey,
                                                             @Nonnull Key key,
                                                             @Nonnull Project project,
                                                             @Nullable GlobalSearchScope scope,
                                                             @Nullable IdFilter idFilter,
                                                             @Nonnull Class<Psi> requiredClass,
                                                             @Nonnull Processor<? super Psi> processor) {
  return processElements(indexKey, key, project, scope, requiredClass, processor);
}
 

public static boolean processFilesByName(@Nonnull final String name,
                                         boolean directories,
                                         boolean caseSensitively,
                                         @Nonnull Processor<? super PsiFileSystemItem> processor,
                                         @Nonnull final GlobalSearchScope scope,
                                         @Nonnull final Project project,
                                         @Nullable IdFilter idFilter) {
  final Collection<VirtualFile> files;

  if (caseSensitively) {
    files = getService().getVirtualFilesByName(project, name, scope, idFilter);
  }
  else {
    files = getVirtualFilesByNameIgnoringCase(name, scope, project, idFilter);
  }

  if (files.isEmpty()) return false;
  PsiManager psiManager = PsiManager.getInstance(project);
  int processedFiles = 0;

  for (VirtualFile file : files) {
    if (!file.isValid()) continue;
    if (!directories && !file.isDirectory()) {
      PsiFile psiFile = psiManager.findFile(file);
      if (psiFile != null) {
        if (!processor.process(psiFile)) return true;
        ++processedFiles;
      }
    }
    else if (directories && file.isDirectory()) {
      PsiDirectory dir = psiManager.findDirectory(file);
      if (dir != null) {
        if (!processor.process(dir)) return true;
        ++processedFiles;
      }
    }
  }
  return processedFiles > 0;
}
 

@Override
public void processNames(@NotNull Processor<? super String> processor, @NotNull GlobalSearchScope globalSearchScope, @Nullable IdFilter idFilter) {
    String queryString = Optional.ofNullable(globalSearchScope.getProject())
        .map(p -> p.getUserData(ChooseByNamePopup.CURRENT_SEARCH_PATTERN)).orElse("");

    workspaceSymbolProvider.workspaceSymbols(queryString, globalSearchScope.getProject()).stream()
        .filter(ni -> globalSearchScope.accept(ni.getFile()))
        .map(NavigationItem::getName)
        .forEach(processor::process);
}
 

@Override
public void processNames(@Nonnull Processor<String> stringProcessor, @Nonnull GlobalSearchScope searchScope, @Nullable IdFilter idFilter)
{
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.METHOD_INDEX, stringProcessor, searchScope, idFilter);
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.EVENT_INDEX, stringProcessor, searchScope, idFilter);
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.PROPERTY_INDEX, stringProcessor, searchScope, idFilter);
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.FIELD_INDEX, stringProcessor, searchScope, idFilter);
}
 

@Override
public void processNames(@NotNull Processor<? super String> processor, @NotNull GlobalSearchScope scope, @Nullable IdFilter filter) {
    Project project = scope.getProject();
    if (project != null) {
        ModuleIndex.getInstance().processAllKeys(project, processor);
    }
}
 

@Nonnull
@Override
public String[] getNames(Project project, boolean includeNonProjectItems)
{
	CommonProcessors.CollectProcessor<String> processor = new CommonProcessors.CollectProcessor<String>(ContainerUtil.<String>newTroveSet());
	processNames(processor, GlobalSearchScope.allScope(project), IdFilter.getProjectIdFilter(project, includeNonProjectItems));
	return processor.toArray(ArrayUtil.STRING_ARRAY_FACTORY);
}
 

@Nonnull
@Override
@RequiredReadAction
public NavigationItem[] getItemsByName(String name, final String pattern, Project project, boolean includeNonProjectItems)
{
	CommonProcessors.CollectProcessor<NavigationItem> processor = new CommonProcessors.CollectProcessor<NavigationItem>(ContainerUtil.<NavigationItem>newTroveSet());
	processElementsWithName(name, processor, new FindSymbolParameters(pattern, name, GlobalSearchScope.allScope(project), IdFilter.getProjectIdFilter(project, includeNonProjectItems)));
	return processor.toArray(NavigationItem.ARRAY_FACTORY);
}
 

@Nonnull
@Override
public String[] getNames(Project project, boolean includeNonProjectItems)
{
	CommonProcessors.CollectProcessor<String> processor = new CommonProcessors.CollectProcessor<String>(ContainerUtil.<String>newTroveSet());
	processNames(processor, GlobalSearchScope.allScope(project), IdFilter.getProjectIdFilter(project, includeNonProjectItems));
	return processor.toArray(ArrayUtil.STRING_ARRAY_FACTORY);
}
 

@Override
public void collectTypes(@Nonnull String s, @Nonnull GlobalSearchScope searchScope, @Nullable IdFilter filter, @Nonnull final Processor<DotNetTypeDeclaration> processor)
{
	StubIndex.getInstance().processElements(CSharpIndexKeys.TYPE_INDEX, s, myProject, searchScope, filter, CSharpTypeDeclaration.class, processor);

	StubIndex.getInstance().processElements(CSharpIndexKeys.DELEGATE_METHOD_BY_NAME_INDEX, s, myProject, searchScope, filter, CSharpMethodDeclaration.class, methodDeclaration ->
	{
		ProgressManager.checkCanceled();

		CSharpTypeDeclaration typeFromDelegate = CSharpLambdaResolveResultUtil.createTypeFromDelegate(methodDeclaration, DotNetGenericExtractor.EMPTY);
		return processor.process(typeFromDelegate);
	});
}
 

@Override
public void processElementsWithName(@Nonnull String name, @Nonnull final Processor<NavigationItem> navigationItemProcessor, @Nonnull FindSymbolParameters findSymbolParameters)
{
	Project project = findSymbolParameters.getProject();
	IdFilter idFilter = findSymbolParameters.getIdFilter();
	Processor temp = navigationItemProcessor;
	GlobalSearchScope searchScope = findSymbolParameters.getSearchScope();

	StubIndex.getInstance().processElements(CSharpIndexKeys.TYPE_INDEX, name, project, searchScope, idFilter, CSharpTypeDeclaration.class, temp);
	StubIndex.getInstance().processElements(CSharpIndexKeys.DELEGATE_METHOD_BY_NAME_INDEX, name, project, searchScope, idFilter, CSharpMethodDeclaration.class, temp);
}
 

@Nonnull
@Override
public NavigationItem[] getItemsByName(String name, String pattern, Project project, boolean includeNonProjectItems)
{
	CommonProcessors.CollectProcessor<NavigationItem> processor = new CommonProcessors.CollectProcessor<NavigationItem>(ContainerUtil.<NavigationItem>newTroveSet());
	processElementsWithName(name, processor, new FindSymbolParameters(pattern, name, GlobalSearchScope.allScope(project), IdFilter.getProjectIdFilter(project, includeNonProjectItems)));
	return processor.toArray(NavigationItem.ARRAY_FACTORY);
}
 

@Override
public void collectTypeNames(@Nonnull Processor<String> processor, @Nonnull GlobalSearchScope searchScope, @Nullable IdFilter filter)
{
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.TYPE_INDEX, processor, searchScope, filter);
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.DELEGATE_METHOD_BY_NAME_INDEX, processor, searchScope, filter);
}
 

IdFilter getIdFilter(boolean withLibraries) {
  return IdFilter.getProjectIdFilter(myProject, withLibraries);
}
 

@Override
public void processAllFileNames(@Nonnull Processor<? super String> processor, @Nonnull GlobalSearchScope scope, IdFilter filter) {
  myIndex.processAllKeys(FilenameIndexImpl.NAME, processor, scope, filter);
}
 

@Override
public void processNames(@Nonnull Processor<String> processor, @Nonnull GlobalSearchScope scope, @Nullable IdFilter filter)
{
	StubIndex.getInstance().processAllKeys(UnityScriptIndexKeys.FILE_BY_NAME_INDEX, processor, scope, filter);
}
 

public <K> boolean processAllKeys(@Nonnull StubIndexKey<K, ?> indexKey, @Nonnull Processor<? super K> processor, @Nonnull GlobalSearchScope scope, @Nullable IdFilter idFilter) {
  return processAllKeys(indexKey, ObjectUtils.assertNotNull(scope.getProject()), processor);
}
 

@Nonnull
Collection<VirtualFile> getVirtualFilesByName(Project project, @Nonnull String name, @Nonnull GlobalSearchScope scope, @Nullable IdFilter idFilter);
 

public static void processAllFileNames(@Nonnull Processor<? super String> processor, @Nonnull GlobalSearchScope scope, @Nullable IdFilter filter) {
  getService().processAllFileNames(processor, scope, filter);
}
 

@Override
public void processNames(@Nonnull Processor<String> stringProcessor, @Nonnull GlobalSearchScope searchScope, @Nullable IdFilter idFilter)
{
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.TYPE_INDEX, stringProcessor, searchScope, idFilter);
	StubIndex.getInstance().processAllKeys(CSharpIndexKeys.DELEGATE_METHOD_BY_NAME_INDEX, stringProcessor, searchScope, idFilter);
}
 

void processNames(@Nonnull Processor<String> processor, @Nonnull GlobalSearchScope scope, @Nullable IdFilter filter); 

void processAllFileNames(@Nonnull Processor<? super String> processor, @Nonnull GlobalSearchScope scope, @Nullable IdFilter filter);