Java 类com.intellij.openapi.application.ReadActionProcessor 实例源码

项目：manifold-ij 文件：ManTypeFinder.java

@Override
public boolean processPackageDirectories(@NotNull PsiPackage psiPackage,
                                         @NotNull final GlobalSearchScope scope,
                                         @NotNull final Processor<PsiDirectory> consumer,
                                         boolean includeLibrarySources) {
  //System.out.println( "processDirectories() : " + psiPackage + " : " + scope );

  final PsiManager psiManager = PsiManager.getInstance( _project );
  return PackageIndex.getInstance( _project )
    .getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources)
    .forEach(new ReadActionProcessor<VirtualFile>() {
      @Override
      public boolean processInReadAction(final VirtualFile dir) {
        if (!scope.contains(dir)) return true;
        PsiDirectory psiDir = psiManager.findDirectory(dir);
        return psiDir == null || consumer.process(psiDir);
      }
    });
}

项目：intellij-ce-playground 文件：PsiAnnotationMethodReferencesSearcher.java

public static ReadActionProcessor<PsiReference> createImplicitDefaultAnnotationMethodConsumer(final Processor<PsiReference> consumer) {
  return new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(final PsiReference reference) {
      if (reference instanceof PsiJavaCodeReferenceElement) {
        PsiJavaCodeReferenceElement javaReference = (PsiJavaCodeReferenceElement)reference;
        if (javaReference.getParent() instanceof PsiAnnotation) {
          PsiNameValuePair[] members = ((PsiAnnotation)javaReference.getParent()).getParameterList().getAttributes();
          if (members.length == 1 && members[0].getNameIdentifier() == null) {
            PsiReference t = members[0].getReference();
            if (t != null && !consumer.process(t)) return false;
          }
        }
      }
      return true;
    }
  };
}

项目：intellij-ce-playground 文件：PsiElementFinderImpl.java

@Override
public boolean processPackageDirectories(@NotNull PsiPackage psiPackage,
                                         @NotNull final GlobalSearchScope scope,
                                         @NotNull final Processor<PsiDirectory> consumer,
                                         boolean includeLibrarySources) {
  final PsiManager psiManager = PsiManager.getInstance(myProject);
  return PackageIndex.getInstance(myProject)
    .getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources)
    .forEach(new ReadActionProcessor<VirtualFile>() {
      @Override
      public boolean processInReadAction(final VirtualFile dir) {
        if (!scope.contains(dir)) return true;
        PsiDirectory psiDir = psiManager.findDirectory(dir);
        return psiDir == null || consumer.process(psiDir);
      }
    });
}

项目：intellij-ce-playground 文件：JavaFindUsagesHelper.java

private static boolean addAliasingUsages(@NotNull PomTarget pomTarget,
                                         @NotNull final FindUsagesOptions options,
                                         @NotNull final Processor<UsageInfo> processor) {
  for (AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME)) {
    for (final AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) {
      boolean success = ReferencesSearch
        .search(new ReferencesSearch.SearchParameters(ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() {
          @Override
          public PsiElement compute() {
            return PomService.convertToPsi(psiTarget);
          }
        }), options.searchScope, false, options.fastTrack))
        .forEach(new ReadActionProcessor<PsiReference>() {
          @Override
          public boolean processInReadAction(final PsiReference reference) {
            return addResult(reference, options, processor);
          }
        });
      if (!success) return false;
    }
  }
  return true;
}

项目：intellij-ce-playground 文件：QuerySearchRequest.java

public QuerySearchRequest(@NotNull Query<PsiReference> query,
                          @NotNull final SearchRequestCollector collector,
                          boolean inReadAction,
                          @NotNull final PairProcessor<PsiReference, SearchRequestCollector> processor) {
  this.query = query;
  this.collector = collector;
  if (inReadAction) {
    this.processor = new ReadActionProcessor<PsiReference>() {
      @Override
      public boolean processInReadAction(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }
  else {
    this.processor = new Processor<PsiReference>() {
      @Override
      public boolean process(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }
}

项目：tools-idea 文件：PsiAnnotationMethodReferencesSearcher.java

public static ReadActionProcessor<PsiReference> createImplicitDefaultAnnotationMethodConsumer(final Processor<PsiReference> consumer) {
  return new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(final PsiReference reference) {
      if (reference instanceof PsiJavaCodeReferenceElement) {
        PsiJavaCodeReferenceElement javaReference = (PsiJavaCodeReferenceElement)reference;
        if (javaReference.getParent() instanceof PsiAnnotation) {
          PsiNameValuePair[] members = ((PsiAnnotation)javaReference.getParent()).getParameterList().getAttributes();
          if (members.length == 1 && members[0].getNameIdentifier() == null) {
            PsiReference t = members[0].getReference();
            if (t != null && !consumer.process(t)) return false;
          }
        }
      }
      return true;
    }
  };
}

项目：tools-idea 文件：ConstructorReferencesSearchHelper.java

private static boolean process18MethodPointers(@NotNull final Processor<PsiReference> processor,
                                               @NotNull final PsiMethod constructor,
                                               @NotNull PsiClass aClass) {
  return ReferencesSearch.search(aClass).forEach(new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(PsiReference reference) {
      final PsiElement element = reference.getElement();
      if (element != null) {
        final PsiElement parent = element.getParent();
        if (parent instanceof PsiMethodReferenceExpression &&
            ((PsiMethodReferenceExpression)parent).getReferenceNameElement() instanceof PsiKeyword) {
          if (((PsiMethodReferenceExpression)parent).isReferenceTo(constructor)) {
            if (!processor.process((PsiReference)parent)) return false;
          }
        }
      }
      return true;
    }
  });
}

项目：tools-idea 文件：JavaPsiFacadeImpl.java

@Override
public boolean processPackageDirectories(@NotNull PsiPackage psiPackage,
                                         @NotNull final GlobalSearchScope scope,
                                         @NotNull final Processor<PsiDirectory> consumer,
                                         boolean includeLibrarySources) {
  final PsiManager psiManager = PsiManager.getInstance(getProject());
  return PackageIndex.getInstance(getProject()).getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources)
    .forEach(new ReadActionProcessor<VirtualFile>() {
      @Override
      public boolean processInReadAction(final VirtualFile dir) {
        if (!scope.contains(dir)) return true;
        PsiDirectory psiDir = psiManager.findDirectory(dir);
        return psiDir == null || consumer.process(psiDir);
      }
    });
}

项目：tools-idea 文件：JavaFindUsagesHandler.java

private static boolean addAliasingUsages(@NotNull PomTarget pomTarget,
                                         @NotNull final Processor<UsageInfo> processor,
                                         @NotNull final FindUsagesOptions options) {
  for (AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME)) {
    for (AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) {
      boolean success = ReferencesSearch
        .search(new ReferencesSearch.SearchParameters(PomService.convertToPsi(psiTarget), options.searchScope, false, options.fastTrack))
        .forEach(new ReadActionProcessor<PsiReference>() {
          @Override
          public boolean processInReadAction(final PsiReference reference) {
            return addResult(processor, reference, options);
          }
        });
      if (!success) return false;
    }
  }
  return true;
}

项目：tools-idea 文件：PsiSearchHelperImpl.java

public boolean processFilesWithText(@NotNull final GlobalSearchScope scope,
                                    final short searchContext,
                                    final boolean caseSensitively,
                                    @NotNull String text,
                                    @NotNull final Processor<VirtualFile> processor) {
  List<IdIndexEntry> entries = getWordEntries(text, caseSensitively);
  if (entries.isEmpty()) return true;

  final CommonProcessors.CollectProcessor<VirtualFile> collectProcessor = new CommonProcessors.CollectProcessor<VirtualFile>();
  processFilesContainingAllKeys(scope, new Condition<Integer>() {
    @Override
    public boolean value(Integer integer) {
      return (integer.intValue() & searchContext) != 0;
    }
  }, collectProcessor, entries);

  final FileIndexFacade index = FileIndexFacade.getInstance(myManager.getProject());
  return ContainerUtil.process(collectProcessor.getResults(), new ReadActionProcessor<VirtualFile>() {
    @Override
    public boolean processInReadAction(VirtualFile virtualFile) {
      return !index.shouldBeFound(scope, virtualFile) || processor.process(virtualFile);
    }
  });
}

项目：tools-idea 文件：QuerySearchRequest.java

public QuerySearchRequest(@NotNull Query<PsiReference> query,
                          @NotNull final SearchRequestCollector collector,
                          boolean inReadAction,
                          @NotNull final PairProcessor<PsiReference, SearchRequestCollector> processor) {
  this.query = query;
  this.collector = collector;
  if (inReadAction) {
    this.processor = new ReadActionProcessor<PsiReference>() {
      @Override
      public boolean processInReadAction(PsiReference psiReference) {
            return processor.process(psiReference, collector);
      }
    };
  } else {
    this.processor = new Processor<PsiReference>() {
      @Override
      public boolean process(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }

}

项目：consulo 文件：PsiSearchHelperImpl.java

@Nonnull
private static Processor<PsiElement> localProcessor(@Nonnull final BulkOccurrenceProcessor processor,
                                                    @Nonnull final ProgressIndicator progress,
                                                    @Nonnull final StringSearcher searcher) {
  return new ReadActionProcessor<PsiElement>() {
    @Override
    public boolean processInReadAction(PsiElement scopeElement) {
      if (scopeElement instanceof PsiCompiledElement) {
        // can't scan text of the element
        return true;
      }

      return scopeElement.isValid() &&
             processor.execute(scopeElement, LowLevelSearchUtil.getTextOccurrencesInScope(scopeElement, searcher, progress), searcher);
    }

    @Override
    public String toString() {
      return processor.toString();
    }
  };
}

项目：consulo 文件：QuerySearchRequest.java

public QuerySearchRequest(Query<PsiReference> query,
                          final SearchRequestCollector collector,
                          boolean inReadAction, final PairProcessor<PsiReference, SearchRequestCollector> processor) {
  this.query = query;
  this.collector = collector;
  if (inReadAction) {
    this.processor = new ReadActionProcessor<PsiReference>() {
      @RequiredReadAction
      @Override
      public boolean processInReadAction(PsiReference psiReference) {
            return processor.process(psiReference, collector);
      }
    };
  } else {
    this.processor = new Processor<PsiReference>() {
      @Override
      public boolean process(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }

}

项目：consulo-java 文件：PsiAnnotationMethodReferencesSearcher.java

public static ReadActionProcessor<PsiReference> createImplicitDefaultAnnotationMethodConsumer(final Processor<PsiReference> consumer) {
  return new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(final PsiReference reference) {
      if (reference instanceof PsiJavaCodeReferenceElement) {
        PsiJavaCodeReferenceElement javaReference = (PsiJavaCodeReferenceElement)reference;
        if (javaReference.getParent() instanceof PsiAnnotation) {
          PsiNameValuePair[] members = ((PsiAnnotation)javaReference.getParent()).getParameterList().getAttributes();
          if (members.length == 1 && members[0].getNameIdentifier() == null) {
            PsiReference t = members[0].getReference();
            if (t != null && !consumer.process(t)) return false;
          }
        }
      }
      return true;
    }
  };
}

项目：consulo-java 文件：JavaPsiFacadeImpl.java

@Override
public boolean processPackageDirectories(@NotNull PsiJavaPackage psiPackage, @NotNull final GlobalSearchScope scope, @NotNull final Processor<PsiDirectory> consumer)
{
    final PsiManager psiManager = PsiManager.getInstance(getProject());
    return DirectoryIndex.getInstance(getProject()).getDirectoriesByPackageName(psiPackage.getQualifiedName(), false).forEach(new ReadActionProcessor<VirtualFile>()
    {
        @RequiredReadAction
        @Override
        public boolean processInReadAction(final VirtualFile dir)
        {
            if(!scope.contains(dir))
            {
                return true;
            }
            PsiDirectory psiDir = psiManager.findDirectory(dir);
            return psiDir == null || consumer.process(psiDir);
        }
    });
}

项目：consulo-java 文件：JavaFindUsagesHelper.java

private static boolean addAliasingUsages(@NotNull PomTarget pomTarget, @NotNull final FindUsagesOptions options, @NotNull final Processor<UsageInfo> processor)
{
    for(AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME))
    {
        for(final AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget))
        {
            boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(ReadAction.compute(() -> PomService.convertToPsi(psiTarget)), options.searchScope, false, options
                    .fastTrack)).forEach(new ReadActionProcessor<PsiReference>()
            {
                @Override
                public boolean processInReadAction(final PsiReference reference)
                {
                    return addResult(reference, options, processor);
                }
            });
            if(!success)
            {
                return false;
            }
        }
    }
    return true;
}

项目：intellij-ce-playground 文件：JavaFindUsagesHelper.java

private static boolean addClassesUsages(@NotNull PsiPackage aPackage,
                                        @NotNull final JavaPackageFindUsagesOptions options,
                                        @NotNull final Processor<UsageInfo> processor) {
  ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
  if (progress != null){
    progress.pushState();
  }

  List<PsiClass> classes = new ArrayList<PsiClass>();
  addClassesInPackage(aPackage, options.isIncludeSubpackages, classes);
  for (final PsiClass aClass : classes) {
    if (progress != null) {
      String name = ApplicationManager.getApplication().runReadAction(new Computable<String>() {
        @Override
        public String compute() {
          return aClass.getName();
        }
      });
      progress.setText(FindBundle.message("find.searching.for.references.to.class.progress", name));
      progress.checkCanceled();
    }
    boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor<PsiReference>() {
      @Override
      public boolean processInReadAction(final PsiReference psiReference) {
        return addResult(psiReference, options, processor);
      }
    });
    if (!success) return false;
  }

  if (progress != null){
    progress.popState();
  }
  return true;
}

项目：intellij-ce-playground 文件：IndexCacheManagerImpl.java

@Override
public boolean processFilesWithWord(@NotNull final Processor<PsiFile> psiFileProcessor, @NotNull final String word, final short occurrenceMask, @NotNull final GlobalSearchScope scope, final boolean caseSensitively) {
  final List<VirtualFile> vFiles = new ArrayList<VirtualFile>(5);
  collectVirtualFilesWithWord(new CommonProcessors.CollectProcessor<VirtualFile>(vFiles), word, occurrenceMask, scope, caseSensitively);
  if (vFiles.isEmpty()) return true;

  final Processor<VirtualFile> virtualFileProcessor = new ReadActionProcessor<VirtualFile>() {
    @Override
    public boolean processInReadAction(VirtualFile virtualFile) {
      if (virtualFile.isValid()) {
        final PsiFile psiFile = myPsiManager.findFile(virtualFile);
        return psiFile == null || psiFileProcessor.process(psiFile);
      }
      return true;
    }
  };


  // IMPORTANT!!!
  // Since implementation of virtualFileProcessor.process() may call indices directly or indirectly,
  // we cannot call it inside FileBasedIndex.processValues() method
  // If we do, deadlocks are possible (IDEADEV-42137). So first we obtain files with the word specified,
  // and then process them not holding indices' read lock.
  for (VirtualFile vFile : vFiles) {
    ProgressIndicatorProvider.checkCanceled();
    if (!virtualFileProcessor.process(vFile)) {
      return false;
    }
  }
  return true;
}

项目：intellij-ce-playground 文件：FindUsagesHandler.java

public boolean processElementUsages(@NotNull final PsiElement element,
                                    @NotNull final Processor<UsageInfo> processor,
                                    @NotNull final FindUsagesOptions options) {
  final ReadActionProcessor<PsiReference> refProcessor = new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(final PsiReference ref) {
      TextRange rangeInElement = ref.getRangeInElement();
      return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false));
    }
  };

  final SearchScope scope = options.searchScope;

  final boolean searchText = options.isSearchForTextOccurrences && scope instanceof GlobalSearchScope;

  if (options.isUsages) {
    boolean success =
      ReferencesSearch.search(new ReferencesSearch.SearchParameters(element, scope, false, options.fastTrack)).forEach(refProcessor);
    if (!success) return false;
  }

  if (searchText) {
    if (options.fastTrack != null) {
      options.fastTrack.searchCustom(new Processor<Processor<PsiReference>>() {
        @Override
        public boolean process(Processor<PsiReference> consumer) {
          return processUsagesInText(element, processor, (GlobalSearchScope)scope);
        }
      });
    }
    else {
      return processUsagesInText(element, processor, (GlobalSearchScope)scope);
    }
  }
  return true;
}

项目：epigraph 文件：SchemaTypeParentsSearcher.java

private static void processParents(@NotNull Processor<SchemaTypeDef> consumer,
                                   @NotNull SchemaTypeDef baseType,
                                   @NotNull SchemaTypeParentsSearch.SearchParameters parameters) {

  final Ref<SchemaTypeDef> currentBase = Ref.create();
  final Queue<PsiAnchor> queue = new Queue<>(10);
  final Set<PsiAnchor> processed = ContainerUtil.newTroveSet();

  final Processor<SchemaTypeDef> processor = new ReadActionProcessor<SchemaTypeDef>() {
    @Override
    public boolean processInReadAction(SchemaTypeDef inheritor) {
      if (!consumer.process(inheritor)) return false;
      if (inheritor == null) return false;
      queue.addLast(PsiAnchor.create(inheritor));
      return true;
    }
  };

  // seed
  ApplicationManager.getApplication().runReadAction(() -> {
    queue.addLast(PsiAnchor.create(baseType));
  });

  // BFS
  while (!queue.isEmpty()) {
    ProgressManager.checkCanceled();

    final PsiAnchor anchor = queue.pullFirst();
    if (!processed.add(anchor)) continue;

    SchemaTypeDef typeDef = ApplicationManager.getApplication().runReadAction(
        (Computable<SchemaTypeDef>) () -> (SchemaTypeDef) anchor.retrieve()
    );
    if (typeDef == null) continue;

    currentBase.set(typeDef);
    if (!SchemaDirectTypeParentsSearch.search(typeDef).forEach(processor))
      return;
  }
}

项目：tools-idea 文件：JavaFindUsagesHandler.java

private static boolean addClassesUsages(@NotNull PsiPackage aPackage,
                                        @NotNull final Processor<UsageInfo> processor,
                                        @NotNull final JavaPackageFindUsagesOptions options) {
  ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
  if (progress != null){
    progress.pushState();
  }

  List<PsiClass> classes = new ArrayList<PsiClass>();
  addClassesInPackage(aPackage, options.isIncludeSubpackages, classes);
  for (final PsiClass aClass : classes) {
    if (progress != null) {
      progress.setText(FindBundle.message("find.searching.for.references.to.class.progress", ApplicationManager.getApplication().runReadAction(new Computable<String>(){
        @Override
        public String compute() {
          return aClass.getName();
        }
      })));
      progress.checkCanceled();
    }
    boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor<PsiReference>() {
      @Override
      public boolean processInReadAction(final PsiReference psiReference) {
        return addResult(processor, psiReference, options);
      }
    });
    if (!success) return false;
  }

  if (progress != null){
    progress.popState();
  }
  return true;
}

项目：tools-idea 文件：IndexCacheManagerImpl.java

@Override
public boolean processFilesWithWord(@NotNull final Processor<PsiFile> psiFileProcessor, @NotNull final String word, final short occurrenceMask, @NotNull final GlobalSearchScope scope, final boolean caseSensitively) {
  final List<VirtualFile> vFiles = new ArrayList<VirtualFile>(5);
  collectVirtualFilesWithWord(new CommonProcessors.CollectProcessor<VirtualFile>(vFiles), word, occurrenceMask, scope, caseSensitively);
  if (vFiles.isEmpty()) return true;

  final Processor<VirtualFile> virtualFileProcessor = new ReadActionProcessor<VirtualFile>() {
    @Override
    public boolean processInReadAction(VirtualFile virtualFile) {
      if (virtualFile.isValid()) {
        final PsiFile psiFile = myPsiManager.findFile(virtualFile);
        return psiFile == null || psiFileProcessor.process(psiFile);
      }
      return true;
    }
  };


  // IMPORTANT!!!
  // Since implementation of virtualFileProcessor.process() may call indices directly or indirectly,
  // we cannot call it inside FileBasedIndex.processValues() method
  // If we do, deadlocks are possible (IDEADEV-42137). So first we obtain files with the word specified,
  // and then process them not holding indices' read lock.
  for (VirtualFile vFile : vFiles) {
    ProgressIndicatorProvider.checkCanceled();
    if (!virtualFileProcessor.process(vFile)) {
      return false;
    }
  }
  return true;
}

项目：tools-idea 文件：FindUsagesHandler.java

public boolean processElementUsages(@NotNull final PsiElement element,
                                    @NotNull final Processor<UsageInfo> processor,
                                    @NotNull final FindUsagesOptions options) {
  final ReadActionProcessor<PsiReference> refProcessor = new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(final PsiReference ref) {
      TextRange rangeInElement = ref.getRangeInElement();
      return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false));
    }
  };

  final SearchScope scope = options.searchScope;

  final boolean searchText = options.isSearchForTextOccurrences && scope instanceof GlobalSearchScope;

  if (options.isUsages) {
    boolean success =
      ReferencesSearch.search(new ReferencesSearch.SearchParameters(element, scope, false, options.fastTrack)).forEach(refProcessor);
    if (!success) return false;
  }

  if (searchText) {
    if (options.fastTrack != null) {
      options.fastTrack.searchCustom(new Processor<Processor<PsiReference>>() {
        @Override
        public boolean process(Processor<PsiReference> consumer) {
          return processUsagesInText(element, processor, (GlobalSearchScope)scope);
        }
      });
    }
    else {
      return processUsagesInText(element, processor, (GlobalSearchScope)scope);
    }
  }
  return true;
}

项目：consulo-csharp 文件：CSharpChangeSignatureUsageProcessor.java

@NotNull
@Override
public UsageInfo[] findUsages(@NotNull final ChangeInfo info)
{
    if(!(info instanceof CSharpChangeInfo))
    {
        return UsageInfo.EMPTY_ARRAY;
    }
    final List<UsageInfo> list = new ArrayList<UsageInfo>();

    final ReadActionProcessor<PsiReference> refProcessor = new ReadActionProcessor<PsiReference>()
    {
        @RequiredReadAction
        @Override
        public boolean processInReadAction(final PsiReference ref)
        {
            final PsiElement resolve = ref.resolve();
            if(resolve != info.getMethod())
            {
                return true;
            }
            TextRange rangeInElement = ref.getRangeInElement();
            list.add(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false));
            return true;
        }
    };

    ReferencesSearch.search(new ReferencesSearch.SearchParameters(info.getMethod(), info.getMethod().getResolveScope(), false)).forEach(refProcessor);
    return list.toArray(UsageInfo.EMPTY_ARRAY);
}

项目：consulo 文件：IndexCacheManagerImpl.java

@Override
public boolean processFilesWithWord(@Nonnull final Processor<PsiFile> psiFileProcessor, @Nonnull final String word, final short occurrenceMask, @Nonnull final GlobalSearchScope scope, final boolean caseSensitively) {
  final List<VirtualFile> vFiles = new ArrayList<VirtualFile>(5);
  collectVirtualFilesWithWord(new CommonProcessors.CollectProcessor<VirtualFile>(vFiles), word, occurrenceMask, scope, caseSensitively);
  if (vFiles.isEmpty()) return true;

  final Processor<VirtualFile> virtualFileProcessor = new ReadActionProcessor<VirtualFile>() {
    @RequiredReadAction
    @Override
    public boolean processInReadAction(VirtualFile virtualFile) {
      if (virtualFile.isValid()) {
        final PsiFile psiFile = myPsiManager.findFile(virtualFile);
        return psiFile == null || psiFileProcessor.process(psiFile);
      }
      return true;
    }
  };


  // IMPORTANT!!!
  // Since implementation of virtualFileProcessor.process() may call indices directly or indirectly,
  // we cannot call it inside FileBasedIndex.processValues() method
  // If we do, deadlocks are possible (IDEADEV-42137). So first we obtain files with the word specified,
  // and then process them not holding indices' read lock.
  for (VirtualFile vFile : vFiles) {
    ProgressIndicatorProvider.checkCanceled();
    if (!virtualFileProcessor.process(vFile)) {
      return false;
    }
  }
  return true;
}

项目：consulo 文件：FindUsagesHandler.java

public boolean processElementUsages(@Nonnull final PsiElement element,
                                    @Nonnull final Processor<UsageInfo> processor,
                                    @Nonnull final FindUsagesOptions options) {
  final ReadActionProcessor<PsiReference> refProcessor = new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(final PsiReference ref) {
      TextRange rangeInElement = ref.getRangeInElement();
      return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false));
    }
  };

  final SearchScope scope = options.searchScope;

  final boolean searchText = options.isSearchForTextOccurrences && scope instanceof GlobalSearchScope;

  if (options.isUsages) {
    boolean success =
            ReferencesSearch.search(new ReferencesSearch.SearchParameters(element, scope, false, options.fastTrack)).forEach(refProcessor);
    if (!success) return false;
  }

  if (searchText) {
    if (options.fastTrack != null) {
      options.fastTrack.searchCustom(consumer -> processUsagesInText(element, processor, (GlobalSearchScope)scope));
    }
    else {
      return processUsagesInText(element, processor, (GlobalSearchScope)scope);
    }
  }
  return true;
}

项目：consulo-java 文件：JavaFunctionalExpressionSearcher.java

private static void searchInFiles(final PsiClass aClass, final Processor<PsiFunctionalExpression> consumer, Set<VirtualFile> filesToProcess, final int expectedFunExprParamsCount)
{
    LOG.info("#usage files: " + filesToProcess.size());
    process(filesToProcess, new ReadActionProcessor<VirtualFile>()
    {
        @RequiredReadAction
        @Override
        public boolean processInReadAction(VirtualFile file)
        {
            //resolve functional expressions to ensure that functional expression type is appropriate
            return processFileWithFunctionalInterfaces(aClass, expectedFunExprParamsCount, consumer, file);
        }
    });
}

项目：intellij-ce-playground 文件：JavaClassInheritorsSearcher.java

private static void processInheritors(@NotNull final Processor<PsiClass> consumer,
                                         @NotNull final PsiClass baseClass,
                                         @NotNull final SearchScope searchScope,
                                         @NotNull final ClassInheritorsSearch.SearchParameters parameters) {
  if (baseClass instanceof PsiAnonymousClass || isFinal(baseClass)) return;

  Project project = PsiUtilCore.getProjectInReadAction(baseClass);
  if (isJavaLangObject(baseClass)) {
    AllClassesSearch.search(searchScope, project, parameters.getNameCondition()).forEach(new Processor<PsiClass>() {
      @Override
      public boolean process(final PsiClass aClass) {
        ProgressManager.checkCanceled();
        return isJavaLangObject(aClass) || consumer.process(aClass);
      }
    });
    return;
  }

  final Ref<PsiClass> currentBase = Ref.create(null);
  final Stack<PsiAnchor> stack = new Stack<PsiAnchor>();
  final Set<PsiAnchor> processed = ContainerUtil.newTroveSet();

  final Processor<PsiClass> processor = new ReadActionProcessor<PsiClass>() {
    @Override
    public boolean processInReadAction(PsiClass candidate) {
      ProgressManager.checkCanceled();

      if (parameters.isCheckInheritance() || parameters.isCheckDeep() && !(candidate instanceof PsiAnonymousClass)) {
        if (!candidate.isInheritor(currentBase.get(), false)) {
          return true;
        }
      }

      if (PsiSearchScopeUtil.isInScope(searchScope, candidate)) {
        if (candidate instanceof PsiAnonymousClass) {
          return consumer.process(candidate);
        }

        final String name = candidate.getName();
        if (name != null && parameters.getNameCondition().value(name) && !consumer.process(candidate)) {
          return false;
        }
      }

      if (parameters.isCheckDeep() && !(candidate instanceof PsiAnonymousClass) && !isFinal(candidate)) {
        stack.push(PsiAnchor.create(candidate));
      }
      return true;
    }
  };

  ApplicationManager.getApplication().runReadAction(new Runnable() {
    @Override
    public void run() {
      stack.push(PsiAnchor.create(baseClass));
    }
  });
  final GlobalSearchScope projectScope = GlobalSearchScope.allScope(project);

  while (!stack.isEmpty()) {
    ProgressManager.checkCanceled();

    final PsiAnchor anchor = stack.pop();
    if (!processed.add(anchor)) continue;

    PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() {
        @Override
        public PsiClass compute() {
          return (PsiClass)anchor.retrieve();
        }
      });
    if (psiClass == null) continue;

    currentBase.set(psiClass);
    if (!DirectClassInheritorsSearch.search(psiClass, projectScope, parameters.isIncludeAnonymous(), false).forEach(processor)) return;
  }
}

项目：intellij-ce-playground 文件：ConfigurationUtil.java

private static boolean addAnnotatedMethodsAnSubclasses(final PsiManager manager, final GlobalSearchScope scope, final TestClassFilter testClassFilter,
                                                       final Set<PsiClass> found,
                                                       final Set<PsiClass> processed,
                                                       final String annotation,
                                                       final boolean isMethod) {
  final Ref<Boolean> isJUnit4 = new Ref<Boolean>(Boolean.FALSE);
  // annotated with @Test
  final PsiClass testAnnotation = ApplicationManager.getApplication().runReadAction(
      new Computable<PsiClass>() {
        @Nullable
        public PsiClass compute() {
          return JavaPsiFacade.getInstance(manager.getProject()).findClass(annotation, GlobalSearchScope.allScope(manager.getProject()));
        }
      }
  );
  if (testAnnotation != null) {
    //allScope is used to find all abstract test cases which probably have inheritors in the current 'scope'
    ClassesWithAnnotatedMembersSearch.search(testAnnotation, GlobalSearchScope.allScope(manager.getProject())).forEach(new Processor<PsiClass>() {
      public boolean process(final PsiClass annotated) {
        AccessToken token = ReadAction.start();
        try {
          if (!processed.add(annotated)) { // don't process the same class twice regardless of it being in the scope
            return true;
          }
          final VirtualFile file = PsiUtilCore.getVirtualFile(annotated);
          if (file != null && scope.contains(file) && testClassFilter.isAccepted(annotated)) {
            if (!found.add(annotated)) {
              return true;
            }
            isJUnit4.set(Boolean.TRUE);
          }
        }
        finally {
          token.finish();
        }

        ClassInheritorsSearch.search(annotated, scope, true, true, false).forEach(new ReadActionProcessor<PsiClass>() {
          @Override
          public boolean processInReadAction(PsiClass aClass) {
            if (testClassFilter.isAccepted(aClass)) {
              found.add(aClass);
              processed.add(aClass);
              isJUnit4.set(Boolean.TRUE);
            }
            return true;
          }
        });
        return true;
      }
    });
  }

  return isJUnit4.get().booleanValue();
}

项目：intellij-ce-playground 文件：GroovyConstructorUsagesSearcher.java

static void processConstructorUsages(final PsiMethod constructor,
                                     final SearchScope searchScope,
                                     final Processor<PsiReference> consumer,
                                     final SearchRequestCollector collector,
                                     final boolean includeOverloads) {
  if (!constructor.isConstructor()) return;

  final PsiClass clazz = constructor.getContainingClass();
  if (clazz == null) return;

  SearchScope onlyGroovy = GroovyScopeUtil.restrictScopeToGroovyFiles(searchScope, GroovyScopeUtil.getEffectiveScope(constructor));
  Set<PsiClass> processed = collector.getSearchSession().getUserData(LITERALLY_CONSTRUCTED_CLASSES);
  if (processed == null) {
    collector.getSearchSession().putUserData(LITERALLY_CONSTRUCTED_CLASSES, processed = ContainerUtil.newConcurrentSet());
  }
  if (!processed.add(clazz)) return;

  if (clazz.isEnum() && clazz instanceof GroovyPsiElement) {
    for (PsiField field : clazz.getFields()) {
      if (field instanceof GrEnumConstant) {
        final PsiReference ref = field.getReference();
        if (ref != null && ref.isReferenceTo(constructor)) {
          if (!consumer.process(ref)) return;
        }
      }
    }
  }

  final LiteralConstructorSearcher literalProcessor = new LiteralConstructorSearcher(constructor, consumer, includeOverloads);

  final Processor<GrNewExpression> newExpressionProcessor = new Processor<GrNewExpression>() {
    @Override
    public boolean process(GrNewExpression grNewExpression) {
      final PsiMethod resolvedConstructor = grNewExpression.resolveMethod();
      if (includeOverloads || constructor.getManager().areElementsEquivalent(resolvedConstructor, constructor)) {
        return consumer.process(grNewExpression.getReferenceElement());
      }
      return true;
    }
  };

  processGroovyClassUsages(clazz, searchScope, collector, newExpressionProcessor, literalProcessor);

  //this()
  if (clazz instanceof GrTypeDefinition) {
    if (!processConstructors(constructor, consumer, clazz, true)) {
      return;
    }
  }
  //super()
  DirectClassInheritorsSearch.search(clazz, onlyGroovy).forEach(new ReadActionProcessor<PsiClass>() {
    @Override
    public boolean processInReadAction(PsiClass inheritor) {
      if (inheritor instanceof GrTypeDefinition) {
        if (!processConstructors(constructor, consumer, inheritor, false)) return false;
      }
      return true;
    }
  });
}

项目：intellij-ce-playground 文件：GroovyMarkerTypes.java

@Override
public void browse(MouseEvent e, PsiElement element) {
  PsiElement parent = element.getParent();
  if (!(parent instanceof GrMethod)) return;
  if (DumbService.isDumb(element.getProject())) {
    DumbService.getInstance(element.getProject()).showDumbModeNotification("Navigation to overriding classes is not possible during index update");
    return;
  }


  //collect all overrings (including fields with implicit accessors and method with default parameters)
  final GrMethod method = (GrMethod)parent;
  final PsiElementProcessor.CollectElementsWithLimit<PsiMethod> collectProcessor =
    new PsiElementProcessor.CollectElementsWithLimit<PsiMethod>(2, new THashSet<PsiMethod>());
  if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
    @Override
    public void run() {
      ApplicationManager.getApplication().runReadAction(new Runnable() {
        @Override
        public void run() {
          for (GrMethod m : PsiImplUtil.getMethodOrReflectedMethods(method)) {
            OverridingMethodsSearch.search(m, true).forEach(new ReadActionProcessor<PsiMethod>() {
              @Override
              public boolean processInReadAction(PsiMethod psiMethod) {
                if (psiMethod instanceof GrReflectedMethod) {
                  psiMethod = ((GrReflectedMethod)psiMethod).getBaseMethod();
                }
                return collectProcessor.execute(psiMethod);
              }
            });
          }
        }
      });
    }
  }, MarkerType.SEARCHING_FOR_OVERRIDING_METHODS, true, method.getProject(), (JComponent)e.getComponent())) {
    return;
  }

  PsiMethod[] overridings = collectProcessor.toArray(PsiMethod.EMPTY_ARRAY);
  if (overridings.length == 0) return;

  PsiElementListCellRenderer<PsiMethod> renderer = new MethodCellRenderer(!PsiUtil.allMethodsHaveSameSignature(overridings));
  Arrays.sort(overridings, renderer.getComparator());
  final OverridingMethodsUpdater methodsUpdater = new OverridingMethodsUpdater(method, renderer);
  PsiElementListNavigator.openTargets(e, overridings, methodsUpdater.getCaption(overridings.length),
                                      "Overriding Methods of " + method.getName(),
                                      renderer, methodsUpdater);

}

项目：epigraph 文件：SchemaTypeInheritorsSearcher.java

private static void processInheritors(@NotNull Processor<SchemaTypeDef> consumer,
                                        @NotNull SchemaTypeDef baseType,
                                        @NotNull SchemaTypeInheritorsSearch.SearchParameters parameters) {

    // see JavaClassInheritorsSearcher

//    final Project project = PsiUtilCore.getProjectInReadAction(baseType);
    final Ref<SchemaTypeDef> currentBase = Ref.create();
    final Stack<PsiAnchor> stack = new Stack<>();
    final Set<PsiAnchor> processed = ContainerUtil.newTroveSet();

    final Processor<SchemaTypeDef> processor = new ReadActionProcessor<SchemaTypeDef>() {
      @Override
      public boolean processInReadAction(SchemaTypeDef inheritor) {
        if (!consumer.process(inheritor)) return false;
        stack.push(PsiAnchor.create(inheritor));
        return true;
      }
    };

    ApplicationManager.getApplication().runReadAction(() -> {
      stack.push(PsiAnchor.create(baseType));
    });

    // DFS
    while (!stack.isEmpty()) {
      ProgressManager.checkCanceled();

      final PsiAnchor anchor = stack.pop();
      if (!processed.add(anchor)) continue;

      SchemaTypeDef typeDef = ApplicationManager.getApplication().runReadAction(
          (Computable<SchemaTypeDef>) () -> (SchemaTypeDef) anchor.retrieve()
      );
      if (typeDef == null) continue;

      currentBase.set(typeDef);
      if (!SchemaDirectTypeInheritorsSearch.search(typeDef).forEach(processor))
        return;
    }
  }

项目：tools-idea 文件：GroovyMarkerTypes.java

@Override
public void browse(MouseEvent e, PsiElement element) {
  PsiElement parent = element.getParent();
  if (!(parent instanceof GrMethod)) return;
  if (DumbService.isDumb(element.getProject())) {
    DumbService.getInstance(element.getProject()).showDumbModeNotification("Navigation to overriding classes is not possible during index update");
    return;
  }


  //collect all overrings (including fields with implicit accessors and method with default parameters)
  final GrMethod method = (GrMethod)parent;
  final PsiElementProcessor.CollectElementsWithLimit<PsiMethod> collectProcessor =
    new PsiElementProcessor.CollectElementsWithLimit<PsiMethod>(2, new THashSet<PsiMethod>());
  if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
    @Override
    public void run() {
      for (GrMethod m : PsiImplUtil.getMethodOrReflectedMethods(method)) {
        OverridingMethodsSearch.search(m, true).forEach(new ReadActionProcessor<PsiMethod>() {
          @Override
          public boolean processInReadAction(PsiMethod psiMethod) {
            if (psiMethod instanceof GrReflectedMethod) {
                psiMethod = ((GrReflectedMethod)psiMethod).getBaseMethod();
            }
            return collectProcessor.execute(psiMethod);
          }
        });
      }
    }
  }, MarkerType.SEARCHING_FOR_OVERRIDING_METHODS, true, method.getProject(), (JComponent)e.getComponent())) {
    return;
  }

  PsiMethod[] overridings = collectProcessor.toArray(PsiMethod.EMPTY_ARRAY);
  if (overridings.length == 0) return;

  PsiElementListCellRenderer<PsiMethod> renderer = new MethodCellRenderer(!PsiUtil.allMethodsHaveSameSignature(overridings));
  Arrays.sort(overridings, renderer.getComparator());
  final OverridingMethodsUpdater methodsUpdater = new OverridingMethodsUpdater(method, renderer);
  PsiElementListNavigator.openTargets(e, overridings, methodsUpdater.getCaption(overridings.length),
                                      "Overriding Methods of " + method.getName(),
                                      renderer, methodsUpdater);

}

项目：tools-idea 文件：GroovyConstructorUsagesSearcher.java

static void processConstructorUsages(final PsiMethod constructor, final SearchScope searchScope, final Processor<PsiReference> consumer, final SearchRequestCollector collector, final boolean searchGppCalls, final boolean includeOverloads) {
  if (!constructor.isConstructor()) return;

  final PsiClass clazz = constructor.getContainingClass();
  if (clazz == null) return;

  SearchScope onlyGroovy = GroovyScopeUtil.restrictScopeToGroovyFiles(searchScope, GroovyScopeUtil.getEffectiveScope(constructor));
  Set<PsiClass> processed = collector.getSearchSession().getUserData(LITERALLY_CONSTRUCTED_CLASSES);
  if (processed == null) {
    collector.getSearchSession().putUserData(LITERALLY_CONSTRUCTED_CLASSES, processed = new ConcurrentHashSet<PsiClass>());
  }
  if (!processed.add(clazz)) return;

  if (clazz.isEnum() && clazz instanceof GroovyPsiElement) {
    for (PsiField field : clazz.getFields()) {
      if (field instanceof GrEnumConstant) {
        final PsiReference ref = field.getReference();
        if (ref != null && ref.isReferenceTo(constructor)) {
          if (!consumer.process(ref)) return;
        }
      }
    }
  }

  final LiteralConstructorSearcher literalProcessor = new LiteralConstructorSearcher(constructor, consumer, includeOverloads);

  final Processor<GrNewExpression> newExpressionProcessor = new Processor<GrNewExpression>() {
    @Override
    public boolean process(GrNewExpression grNewExpression) {
      final PsiMethod resolvedConstructor = grNewExpression.resolveMethod();
      if (includeOverloads || constructor.getManager().areElementsEquivalent(resolvedConstructor, constructor)) {
        return consumer.process(grNewExpression.getReferenceElement());
      }
      return true;
    }
  };

  processGroovyClassUsages(clazz, searchScope, collector, searchGppCalls, newExpressionProcessor, literalProcessor);

  //this()
  if (clazz instanceof GrTypeDefinition) {
    if (!processConstructors(constructor, consumer, clazz, true)) {
      return;
    }
  }
  //super()
  DirectClassInheritorsSearch.search(clazz, onlyGroovy).forEach(new ReadActionProcessor<PsiClass>() {
    @Override
    public boolean processInReadAction(PsiClass inheritor) {
      if (inheritor instanceof GrTypeDefinition) {
        if (!processConstructors(constructor, consumer, inheritor, false)) return false;
      }
      return true;
    }
  });
}

项目：consulo-java 文件：JavaFunctionalExpressionSearcher.java

/**
 * Collect files where:
 * aClass is used, e.g. in type declaration or method return type;
 * fields with type aClass are used on the left side of assignments. Should find Bar of the following example
 * <pre/>
 * class Foo {
 * Runnable myRunnable;
 * }
 * <p/>
 * class Bar {
 * void foo(Foo foo){
 * foo.myRunnable = () -> {};
 * }
 * }
 * </pre>
 */
private static void collectFilesWithTypeOccurrencesAndFieldAssignments(PsiClass aClass, GlobalSearchScope filesScope, final LinkedHashSet<VirtualFile> usageFiles)
{
    final Set<PsiField> fields = new LinkedHashSet<PsiField>();
    for(final PsiReference reference : ReferencesSearch.search(aClass, filesScope))
    {
        ApplicationManager.getApplication().runReadAction(new Runnable()
        {
            @Override
            public void run()
            {
                final PsiElement element = reference.getElement();
                if(element != null)
                {
                    addIfNotNull(usageFiles, PsiUtilCore.getVirtualFile(element));
                    final PsiElement parent = element.getParent();
                    if(parent instanceof PsiTypeElement)
                    {
                        final PsiElement gParent = parent.getParent();
                        if(gParent instanceof PsiField &&
                                !((PsiField) gParent).hasModifierProperty(PsiModifier.PRIVATE) &&
                                !((PsiField) gParent).hasModifierProperty(PsiModifier.FINAL))
                        {
                            fields.add((PsiField) gParent);
                        }
                    }
                }
            }
        });
    }

    for(PsiField field : fields)
    {
        ReferencesSearch.search(field, filesScope).forEach(new ReadActionProcessor<PsiReference>()
        {
            @Override
            public boolean processInReadAction(PsiReference fieldRef)
            {
                final PsiElement fieldElement = fieldRef.getElement();
                final PsiAssignmentExpression varElementParent = PsiTreeUtil.getParentOfType(fieldElement, PsiAssignmentExpression.class);
                if(varElementParent != null && PsiTreeUtil.isAncestor(varElementParent.getLExpression(), fieldElement, false))
                {
                    addIfNotNull(usageFiles, PsiUtilCore.getVirtualFile(fieldElement));
                }
                return true;
            }
        });
    }
}

项目：consulo-java 文件：JavaFindUsagesHelper.java

private static boolean addClassesUsages(@NotNull PsiPackage aPackage, @NotNull final JavaPackageFindUsagesOptions options, @NotNull final Processor<UsageInfo> processor)
{
    ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
    if(progress != null)
    {
        progress.pushState();
    }

    try
    {
        List<PsiClass> classes = new ArrayList<>();
        addClassesInPackage(aPackage, options.isIncludeSubpackages, classes);
        for(final PsiClass aClass : classes)
        {
            if(progress != null)
            {
                String name = ReadAction.compute(aClass::getName);
                progress.setText(FindBundle.message("find.searching.for.references.to.class.progress", name));
            }
            ProgressManager.checkCanceled();
            boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor<PsiReference>()
            {
                @Override
                public boolean processInReadAction(final PsiReference psiReference)
                {
                    return addResult(psiReference, options, processor);
                }
            });
            if(!success)
            {
                return false;
            }
        }
    }
    finally
    {
        if(progress != null)
        {
            progress.popState();
        }
    }

    return true;
}