Java ContainerUtil.quickSort方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public List<RefElement> getSortedElements() {
  List<RefElement> answer;
  synchronized (myRefTable) {
    answer = new ArrayList<RefElement>(myRefTable.values());
  }
  ContainerUtil.quickSort(answer, new Comparator<RefElement>() {
    @Override
    public int compare(RefElement o1, RefElement o2) {
      VirtualFile v1 = ((RefElementImpl)o1).getVirtualFile();
      VirtualFile v2 = ((RefElementImpl)o2).getVirtualFile();

      return (v1 != null ? v1.hashCode() : 0) - (v2 != null ? v2.hashCode() : 0);
    }
  });

  return answer;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public ResolveResult[] multiResolve(final boolean incompleteCode) {
  final String key = getKeyText();

  List<IProperty> properties;
  final List<PropertiesFile> propertiesFiles = getPropertiesFiles();
  if (propertiesFiles == null) {
    properties = PropertiesImplUtil.findPropertiesByKey(getElement().getProject(), key);
  }
  else {
    properties = new ArrayList<IProperty>();
    for (PropertiesFile propertiesFile : propertiesFiles) {
      properties.addAll(propertiesFile.findPropertiesByKey(key));
    }
  }
  // put default properties file first
  ContainerUtil.quickSort(properties, new Comparator<IProperty>() {
    public int compare(final IProperty o1, final IProperty o2) {
      String name1 = o1.getPropertiesFile().getName();
      String name2 = o2.getPropertiesFile().getName();
      return Comparing.compare(name1, name2);
    }
  });
  return getResolveResults(properties);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
@Override
public PsiClass[] findClasses(@NotNull String qName, @NotNull final GlobalSearchScope scope) {
  final Collection<PsiClass> classes = JavaFullClassNameIndex.getInstance().get(qName.hashCode(), myManager.getProject(), scope);
  if (classes.isEmpty()) return PsiClass.EMPTY_ARRAY;
  List<PsiClass> result = new ArrayList<PsiClass>(classes.size());
  for (PsiClass aClass : classes) {
    final String qualifiedName = aClass.getQualifiedName();
    if (qualifiedName == null || !qualifiedName.equals(qName)) continue;

    PsiUtilCore.ensureValid(aClass);
    PsiFile file = aClass.getContainingFile();
    if (file == null) {
      throw new AssertionError("No file for class: " + aClass + " of " + aClass.getClass());
    }

    VirtualFile vFile = file.getVirtualFile();
    if (!hasAcceptablePackage(vFile)) continue;

    result.add(aClass);
  }

  int count = result.size();
  if (count == 0) return PsiClass.EMPTY_ARRAY;
  if (count == 1) return new PsiClass[] {result.get(0)};

  ContainerUtil.quickSort(result, new Comparator<PsiClass>() {
    @Override
    public int compare(PsiClass o1, PsiClass o2) {
      return scope.compare(o2.getContainingFile().getVirtualFile(), o1.getContainingFile().getVirtualFile());
    }
  });

  return result.toArray(new PsiClass[count]);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
@NotNull
public PsiClass[] getClasses(@Nullable String shortName, @NotNull PsiPackage psiPackage, @NotNull final GlobalSearchScope scope) {
  List<PsiClass> list = null;
  String packageName = psiPackage.getQualifiedName();
  for (PsiDirectory dir : psiPackage.getDirectories(scope)) {
    PsiClass[] classes = JavaDirectoryService.getInstance().getClasses(dir);
    if (classes.length == 0) continue;
    if (list == null) list = new ArrayList<PsiClass>();
    for (PsiClass aClass : classes) {
      // class file can be located in wrong place inside file system
      String qualifiedName = aClass.getQualifiedName();
      if (qualifiedName != null) qualifiedName = StringUtil.getPackageName(qualifiedName);
      if (Comparing.strEqual(qualifiedName, packageName)) {
        if (shortName == null || shortName.equals(aClass.getName())) list.add(aClass);
      }
    }
  }
  if (list == null) {
    return PsiClass.EMPTY_ARRAY;
  }

  if (list.size() > 1) {
    ContainerUtil.quickSort(list, new Comparator<PsiClass>() {
      @Override
      public int compare(PsiClass o1, PsiClass o2) {
        VirtualFile file1 = PsiUtilCore.getVirtualFile(o1);
        VirtualFile file2 = PsiUtilCore.getVirtualFile(o2);
        return file1 == null ? file2 == null ? 0 : -1 : file2 == null ? 1 : scope.compare(file2, file1);
      }
    });
  }

  return list.toArray(new PsiClass[list.size()]);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Nullable
public Color getPastFileEndBackground() {
  boolean isInCaretRow = myEditor.getCaretModel().getLogicalPosition().line >= myDocument.getLineCount() - 1;

  Color caret = isInCaretRow && myCaretRowAttributes != null ? myCaretRowAttributes.getBackgroundColor() : null;

  ContainerUtil.quickSort(myCurrentHighlighters, LayerComparator.INSTANCE);

  //noinspection ForLoopReplaceableByForEach
  for (int i = 0; i < myCurrentHighlighters.size(); i++) {
    RangeHighlighterEx highlighter = myCurrentHighlighters.get(i);
    if (caret != null && highlighter.getLayer() < HighlighterLayer.CARET_ROW) {
      return caret;
    }

    if (highlighter.getTargetArea() != HighlighterTargetArea.LINES_IN_RANGE
        || myDocument.getLineNumber(highlighter.getEndOffset()) < myDocument.getLineCount() - 1) {
      continue;
    }

    TextAttributes textAttributes = highlighter.getTextAttributes();
    if (textAttributes != null) {
      Color backgroundColor = textAttributes.getBackgroundColor();
      if (backgroundColor != null) return backgroundColor;
    }
  }

  return caret;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static void sortById(@NotNull List<TextEditorHighlightingPass> result) {
  ContainerUtil.quickSort(result, new Comparator<TextEditorHighlightingPass>() {
    @Override
    public int compare(@NotNull TextEditorHighlightingPass o1, @NotNull TextEditorHighlightingPass o2) {
      return o1.getId() - o2.getId();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public TooltipRenderer calcTooltipRenderer(@NotNull final Collection<RangeHighlighter> highlighters) {
  LineTooltipRenderer bigRenderer = null;
  List<HighlightInfo> infos = new SmartList<HighlightInfo>();
  Collection<String> tooltips = new THashSet<String>(); //do not show same tooltip twice
  for (RangeHighlighter marker : highlighters) {
    final Object tooltipObject = marker.getErrorStripeTooltip();
    if (tooltipObject == null) continue;
    if (tooltipObject instanceof HighlightInfo) {
      HighlightInfo info = (HighlightInfo)tooltipObject;
      if (info.getToolTip() != null && tooltips.add(info.getToolTip())) {
        infos.add(info);
      }
    }
    else {
      final String text = tooltipObject.toString();
      if (tooltips.add(text)) {
        if (bigRenderer == null) {
          bigRenderer = new MyRenderer(text, new Object[] {highlighters});
        }
        else {
          bigRenderer.addBelow(text);
        }
      }
    }
  }
  if (!infos.isEmpty()) {
    // show errors first
    ContainerUtil.quickSort(infos, new Comparator<HighlightInfo>() {
      @Override
      public int compare(final HighlightInfo o1, final HighlightInfo o2) {
        int i = SeverityRegistrar.getSeverityRegistrar(myProject).compare(o2.getSeverity(), o1.getSeverity());
        if (i != 0) return i;
        return o1.getToolTip().compareTo(o2.getToolTip());
      }
    });
    final HighlightInfoComposite composite = new HighlightInfoComposite(infos);
    if (bigRenderer == null) {
      bigRenderer = new MyRenderer(UIUtil.convertSpace2Nbsp(composite.getToolTip()), new Object[] {highlighters});
    }
    else {
      final LineTooltipRenderer renderer = new MyRenderer(UIUtil.convertSpace2Nbsp(composite.getToolTip()), new Object[] {highlighters});
      renderer.addBelow(bigRenderer.getText());
      bigRenderer = renderer;
    }
  }
  return bigRenderer;
}