Java CommonProcessors类代码示例

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
@Override
@NotNull
public PsiMethod[] getMethodsByNameIfNotMoreThan(@NonNls @NotNull final String name, @NotNull final GlobalSearchScope scope, final int maxCount) {
  final List<PsiMethod> methods = new SmartList<PsiMethod>();
  StubIndex.getInstance().processElements(JavaStubIndexKeys.METHODS, name, myManager.getProject(), scope, PsiMethod.class, new
                                          CommonProcessors.CollectProcessor < PsiMethod > (methods){
  @Override
    public boolean process(PsiMethod method) {
      return methods.size() != maxCount && super.process(method);
    }
  });
  if (methods.isEmpty()) return PsiMethod.EMPTY_ARRAY;

  List<PsiMethod> list = filterMembers(methods, scope);
  return list.toArray(new PsiMethod[list.size()]);
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
@Override
@NotNull
public PsiField[] getFieldsByNameIfNotMoreThan(@NotNull String name, @NotNull final GlobalSearchScope scope, final int maxCount) {
  final List<PsiField> methods = new SmartList<PsiField>();
  StubIndex.getInstance().processElements(JavaStubIndexKeys.FIELDS, name, myManager.getProject(), scope, PsiField.class, new
                                          CommonProcessors.CollectProcessor < PsiField > (methods){
  @Override
    public boolean process(PsiField method) {
      return methods.size() != maxCount && super.process(method);
    }
  });
  if (methods.isEmpty()) return PsiField.EMPTY_ARRAY;

  List<PsiField> list = filterMembers(methods, scope);
  return list.toArray(new PsiField[list.size()]);
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
public static <T extends PsiModifierListOwner> List<T> getSuperAnnotationOwners(final T element) {
  return CachedValuesManager.getCachedValue(element, new CachedValueProvider<List<T>>() {
    @Nullable
    @Override
    public Result<List<T>> compute() {
      LinkedHashSet<PsiModifierListOwner> result = ContainerUtil.newLinkedHashSet();
      if (element instanceof PsiMethod) {
        collectSuperMethods(result, ((PsiMethod)element).getHierarchicalMethodSignature(), element,
                            JavaPsiFacade.getInstance(element.getProject()).getResolveHelper());
      } else if (element instanceof PsiClass) {
        //noinspection unchecked
        InheritanceUtil.processSupers((PsiClass)element, false, new CommonProcessors.CollectProcessor<PsiClass>((Set)result));
      } else if (element instanceof PsiParameter) {
        collectSuperParameters(result, (PsiParameter)element);
      }

      List<T> list = new ArrayList<T>();
      //noinspection unchecked
      list.addAll((Collection<? extends T>)result);
      
      List<Object> dependencies = ContainerUtil.<Object>newArrayList(result);
      dependencies.add(PsiModificationTracker.MODIFICATION_COUNT);
      return Result.create(list, dependencies);
    }
  });
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
@NotNull
public Collection<? extends PsiMethod> getVariants(final ConvertContext context) {
  LinkedHashSet<PsiMethod> methodList = new LinkedHashSet<PsiMethod>();
  Processor<PsiMethod> processor = CommonProcessors.notNullProcessor(new CommonProcessors.CollectProcessor<PsiMethod>(methodList));
  processMethods(context, processor, new Function<PsiClass, PsiMethod[]>() {
    public PsiMethod[] fun(final PsiClass s) {
      final List<PsiMethod> list = ContainerUtil.findAll(getVariants(s), new Condition<PsiMethod>() {
        public boolean value(final PsiMethod object) {
          return acceptMethod(object, context);
        }
      });
      return list.toArray(new PsiMethod[list.size()]);
    }
  });
  return methodList;
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
@NotNull
public static Set<PsiMethodCallExpression> searchMethodCalls(@NotNull final PsiMethod psiMethod, @NotNull SearchScope searchScope) {
  final Set<PsiMethodCallExpression> callExpressions = new com.intellij.util.containers.HashSet<PsiMethodCallExpression>();
  final CommonProcessors.CollectUniquesProcessor<PsiReference> consumer = new CommonProcessors.CollectUniquesProcessor<PsiReference>();

  MethodReferencesSearch.search(psiMethod, searchScope, true).forEach(consumer);

  for (PsiReference psiReference : consumer.getResults()) {
    final PsiMethodCallExpression methodCallExpression =
      PsiTreeUtil.getParentOfType(psiReference.getElement(), PsiMethodCallExpression.class);

    if (methodCallExpression != null) {
      callExpressions.add(methodCallExpression);
    }
  }


  return callExpressions;
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
public void testFindInPathInLibraryDirActuallySearchesInTheirSourcesToo() throws Exception {
  FindModel model = new FindModel();
  final PsiClass aClass = myJavaFacade.findClass("LibraryClass1");
  assertNotNull(aClass);
  model.setDirectoryName(aClass.getContainingFile().getContainingDirectory().getVirtualFile().getPath());
  model.setCaseSensitive(true);
  model.setCustomScope(false);
  model.setStringToFind("LibraryClass1");
  model.setProjectScope(false);

  List<UsageInfo> usages = new ArrayList<>();
  FindInProjectUtil.findUsages(model, getProject(),
                               new CommonProcessors.CollectProcessor<>(
                                 usages), FindInProjectUtil
                                 .setupProcessPresentation(getProject(), false, FindInProjectUtil.setupViewPresentation(false, model)));

  assertEquals(2, usages.size());
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
public void testFindInPathInLibrarySourceDirShouldSearchJustInThisDirectoryOnly() throws Exception {
  FindModel model = new FindModel();
  final PsiClass aClass = myJavaFacade.findClass("x.X");
  assertNotNull(aClass);
  String classDirPath = aClass.getContainingFile().getContainingDirectory().getVirtualFile().getPath();
  String sourceDirPath = ((PsiFile)aClass.getContainingFile().getNavigationElement()).getContainingDirectory().getVirtualFile().getPath();
  assertFalse(classDirPath.equals(sourceDirPath));
  model.setDirectoryName(sourceDirPath);
  model.setCaseSensitive(true);
  model.setCustomScope(false);
  model.setStringToFind("xxx");
  model.setProjectScope(false);

  List<UsageInfo> usages = new ArrayList<>();
  FindInProjectUtil.findUsages(model, getProject(),
                               new CommonProcessors.CollectProcessor<>(
                                 usages), FindInProjectUtil
                                 .setupProcessPresentation(getProject(), false, FindInProjectUtil.setupViewPresentation(false, model)));

  UsageInfo info = assertOneElement(usages);
  assertEquals("X.java", info.getFile().getName());
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
private ModuleCompileScope(Project project, final Collection<Module> modules, boolean includeDependentModules, boolean includeRuntimeDeps) {
  myProject = project;
  myScopeModules = new HashSet<Module>();
  for (Module module : modules) {
    if (module == null) {
      continue; // prevent NPE
    }
    if (includeDependentModules) {
      OrderEnumerator enumerator = ModuleRootManager.getInstance(module).orderEntries().recursively();
      if (!includeRuntimeDeps) {
        enumerator = enumerator.compileOnly();
      }
      enumerator.forEachModule(new CommonProcessors.CollectProcessor<Module>(myScopeModules));
    }
    else {
      myScopeModules.add(module);
    }
  }
  myModules = ModuleManager.getInstance(myProject).getModules();
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
private static void flashUsageScriptaculously(@NotNull final Usage usage) {
  if (!(usage instanceof UsageInfo2UsageAdapter)) {
    return;
  }
  UsageInfo2UsageAdapter usageInfo = (UsageInfo2UsageAdapter)usage;

  Editor editor = usageInfo.openTextEditor(true);
  if (editor == null) return;
  TextAttributes attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(CodeInsightColors.BLINKING_HIGHLIGHTS_ATTRIBUTES);

  RangeBlinker rangeBlinker = new RangeBlinker(editor, attributes, 6);
  List<Segment> segments = new ArrayList<Segment>();
  CommonProcessors.CollectProcessor<Segment> processor = new CommonProcessors.CollectProcessor<Segment>(segments);
  usageInfo.processRangeMarkers(processor);
  rangeBlinker.resetMarkers(segments);
  rangeBlinker.startBlinking();
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
private void getFilesWithText(@NotNull GlobalSearchScope scope,
                              final short searchContext,
                              final boolean caseSensitively,
                              @NotNull String text,
                              @NotNull final ProgressIndicator progress,
                              @NotNull Collection<VirtualFile> result) {
  myManager.startBatchFilesProcessingMode();
  try {
    Processor<VirtualFile> processor = new CommonProcessors.CollectProcessor<VirtualFile>(result){
      @Override
      public boolean process(VirtualFile file) {
        progress.checkCanceled();
        return super.process(file);
      }
    };
    boolean success = processFilesWithText(scope, searchContext, caseSensitively, text, processor);
    // success == false means exception in index
  }
  finally {
    myManager.finishBatchFilesProcessingMode();
  }
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
private HighlighterSweep(@NotNull MarkupModelEx markupModel, int start, int end, final boolean onlyFullLine) {
  // we have to get all highlighters in advance and sort them by affected offsets
  // since these can be different from the real offsets the highlighters are sorted by in the tree.  (See LINES_IN_RANGE perverts)
  final List<RangeHighlighterEx> list = new ArrayList<RangeHighlighterEx>();
  markupModel.processRangeHighlightersOverlappingWith(myReverseIteration ? end : start, 
                                                      myReverseIteration ? start : end,
                                                      new CommonProcessors.CollectProcessor<RangeHighlighterEx>(list) {
                                                        @Override
                                                        protected boolean accept(RangeHighlighterEx ex) {
                                                          return !onlyFullLine || ex.getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE;
                                                        }
                                                      });
  highlighters = list.isEmpty() ? RangeHighlighterEx.EMPTY_ARRAY : list.toArray(new RangeHighlighterEx[list.size()]);
  Arrays.sort(highlighters, myReverseIteration ? BY_AFFECTED_END_OFFSET_REVERSED : RangeHighlighterEx.BY_AFFECTED_START_OFFSET);

  while (i < highlighters.length) {
    RangeHighlighterEx highlighter = highlighters[i++];
    if (!skipHighlighter(highlighter)) {
      myNextHighlighter = highlighter;
      break;
    }
  }
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
private HighlighterSweep(@NotNull MarkupModelEx markupModel, int start, int end, final boolean onlyFullLine) {
  // we have to get all highlighters in advance and sort them by affected offsets
  // since these can be different from the real offsets the highlighters are sorted by in the tree.  (See LINES_IN_RANGE perverts)
  final List<RangeHighlighterEx> list = new ArrayList<RangeHighlighterEx>();
  markupModel.processRangeHighlightersOverlappingWith(start, end, new CommonProcessors.CollectProcessor<RangeHighlighterEx>(list) {
    @Override
    protected boolean accept(RangeHighlighterEx ex) {
      return !onlyFullLine || ex.getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE;
    }
  });
  highlighters = list.isEmpty() ? RangeHighlighterEx.EMPTY_ARRAY : list.toArray(new RangeHighlighterEx[list.size()]);
  Arrays.sort(highlighters, RangeHighlighterEx.BY_AFFECTED_START_OFFSET);

  while (i < highlighters.length) {
    RangeHighlighterEx highlighter = highlighters[i++];
    if (!skipHighlighter(highlighter)) {
      myNextHighlighter = highlighter;
      break;
    }
  }
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
public static List<RangeHighlighter> getHyperlinks(int startOffset, int endOffset, final Editor editor) {
  final MarkupModelEx markupModel = (MarkupModelEx)editor.getMarkupModel();
  final CommonProcessors.CollectProcessor<RangeHighlighterEx> processor = new CommonProcessors.CollectProcessor<RangeHighlighterEx>();
  markupModel.processRangeHighlightersOverlappingWith(startOffset, endOffset,
                                                      new FilteringProcessor<RangeHighlighterEx>(new Condition<RangeHighlighterEx>() {
                                                        @Override
                                                        public boolean value(RangeHighlighterEx rangeHighlighterEx) {
                                                          return rangeHighlighterEx.getEditorFilter().avaliableIn(editor) &&
                                                                 HYPERLINK_LAYER == rangeHighlighterEx.getLayer() &&
                                                                 rangeHighlighterEx.isValid() &&
                                                                 getHyperlinkInfo(rangeHighlighterEx) != null;
                                                        }
                                                      }, processor)
  );
  return new ArrayList<RangeHighlighter>(processor.getResults());
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
public void testRangeHighlighterLinesInRangeForLongLinePerformance() throws Exception {
  final int N = 50000;
  Document document = EditorFactory.getInstance().createDocument(StringUtil.repeatSymbol('x', 2 * N));

  final MarkupModelEx markupModel = (MarkupModelEx)DocumentMarkupModel.forDocument(document, ourProject, true);
  for (int i=0; i<N-1;i++) {
    markupModel.addRangeHighlighter(2*i, 2*i+1, 0, null, HighlighterTargetArea.EXACT_RANGE);
  }
  markupModel.addRangeHighlighter(N / 2, N / 2 + 1, 0, null, HighlighterTargetArea.LINES_IN_RANGE);

  PlatformTestUtil.startPerformanceTest("slow highlighters lookup", (int)(N*Math.log(N)/1000), new ThrowableRunnable() {
    @Override
    public void run() {
      List<RangeHighlighterEx> list = new ArrayList<RangeHighlighterEx>();
      CommonProcessors.CollectProcessor<RangeHighlighterEx> coll = new CommonProcessors.CollectProcessor<RangeHighlighterEx>(list);
      for (int i=0; i<N-1;i++) {
        list.clear();
        markupModel.processRangeHighlightersOverlappingWith(2*i, 2*i+1, coll);
        assertEquals(2, list.size());  // 1 line plus one exact range marker
      }
    }
  }).assertTiming();
}
 

import com.intellij.util.CommonProcessors; //导入依赖的package包/类
private Object calculateRoot(DataContext dataContext) {
  // Narrow down the root element to the first interesting one
  Object root = LangDataKeys.MODULE.getData(dataContext);
  if (root != null) return root;

  Project project = CommonDataKeys.PROJECT.getData(dataContext);
  if (project == null) return null;

  Object projectChild;
  Object projectGrandChild = null;

  CommonProcessors.FindFirstAndOnlyProcessor<Object> processor = new CommonProcessors.FindFirstAndOnlyProcessor<Object>();
  processChildren(project, processor);
  projectChild = processor.reset();
  if (projectChild != null) {
    processChildren(projectChild, processor);
    projectGrandChild = processor.reset();
  }
  return ObjectUtils.chooseNotNull(projectGrandChild, ObjectUtils.chooseNotNull(projectChild, project));
}