platform/lang-impl/src/com/intellij/codeInspection/ui/InspectionResultsViewComparator.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * Created by IntelliJ IDEA.
  19  * User: max
  20  * Date: Nov 23, 2001
  21  * Time: 10:31:03 PM
  22  * To change template for new class use
  23  * Code Style | Class Templates options (Tools | IDE Options).
  24  */
  25 package com.intellij.codeInspection.ui;
  26
  27 import com.intellij.codeInsight.daemon.impl.SeverityRegistrar;
  28 import com.intellij.codeInspection.CommonProblemDescriptor;
  29 import com.intellij.codeInspection.ProblemDescriptor;
  30 import com.intellij.codeInspection.offline.OfflineProblemDescriptor;
  31 import com.intellij.codeInspection.offlineViewer.OfflineRefElementNode;
  32 import com.intellij.codeInspection.reference.RefElement;
  33 import com.intellij.codeInspection.reference.RefEntity;
  34 import com.intellij.openapi.diagnostic.Logger;
  35 import com.intellij.openapi.editor.Document;
  36 import com.intellij.openapi.util.Comparing;
  37 import com.intellij.openapi.util.text.StringUtil;
  38 import com.intellij.profile.codeInspection.ui.inspectionsTree.InspectionsConfigTreeComparator;
  39 import com.intellij.psi.PsiDocumentManager;
  40 import com.intellij.psi.PsiElement;
  41 import com.intellij.psi.PsiNamedElement;
  42 import com.intellij.psi.PsiQualifiedNamedElement;
  43 import com.intellij.psi.util.PsiUtilCore;
  44
  45 import java.util.Comparator;
  46
  47 public class InspectionResultsViewComparator implements Comparator {
  48   private static final Logger LOG = Logger.getInstance(InspectionResultsViewComparator.class);
  49
  50   public boolean areEqual(Object o1, Object o2) {
  51     return o1.getClass().equals(o2.getClass()) && compare(o1, o2) == 0;
  52   }
  53
  54   @Override
  55   public int compare(Object o1, Object o2) {
  56     InspectionTreeNode node1 = (InspectionTreeNode)o1;
  57     InspectionTreeNode node2 = (InspectionTreeNode)o2;
  58
  59     if (node1 instanceof InspectionSeverityGroupNode && node2 instanceof InspectionSeverityGroupNode) {
  60       final InspectionSeverityGroupNode groupNode1 = (InspectionSeverityGroupNode)node1;
  61       final InspectionSeverityGroupNode groupNode2 = (InspectionSeverityGroupNode)node2;
  62       return -SeverityRegistrar.getSeverityRegistrar(groupNode1.getProject()).compare(groupNode1.getSeverityLevel().getSeverity(), groupNode2.getSeverityLevel().getSeverity());
  63     }
  64     if (node1 instanceof InspectionSeverityGroupNode) return -1;
  65     if (node2 instanceof InspectionSeverityGroupNode) return 1;
  66
  67     if (node1 instanceof InspectionGroupNode && node2 instanceof InspectionGroupNode) {
  68       return ((InspectionGroupNode)node1).getGroupTitle().compareToIgnoreCase(((InspectionGroupNode)node2).getGroupTitle());
  69     }
  70     if (node1 instanceof InspectionGroupNode) return -1;
  71     if (node2 instanceof InspectionGroupNode) return 1;
  72
  73     if (node1 instanceof InspectionNode && node2 instanceof InspectionNode)
  74       return InspectionsConfigTreeComparator.getDisplayTextToSort(node1.toString())
  75         .compareToIgnoreCase(InspectionsConfigTreeComparator.getDisplayTextToSort(node2.toString()));
  76     if (node1 instanceof InspectionNode) return -1;
  77     if (node2 instanceof InspectionNode) return 1;
  78
  79     if (node1 instanceof InspectionModuleNode && node2 instanceof InspectionModuleNode) {
  80       return Comparing.compare(node1.toString(), node2.toString());
  81     }
  82     if (node1 instanceof InspectionModuleNode) return -1;
  83     if (node2 instanceof InspectionModuleNode) return 1;
  84
  85     if (node1 instanceof InspectionPackageNode && node2 instanceof InspectionPackageNode) {
  86       return ((InspectionPackageNode)node1).getPackageName().compareToIgnoreCase(((InspectionPackageNode)node2).getPackageName());
  87     }
  88     if (node1 instanceof InspectionPackageNode) return -1;
  89     if (node2 instanceof InspectionPackageNode) return 1;
  90
  91     if (node1 instanceof OfflineRefElementNode && node2 instanceof OfflineRefElementNode) {
  92       final Object userObject1 = ((OfflineRefElementNode)node1).getOfflineDescriptor();
  93       final Object userObject2 = ((OfflineRefElementNode)node2).getOfflineDescriptor();
  94       final OfflineProblemDescriptor descriptor1 = (OfflineProblemDescriptor)userObject1;
  95       final OfflineProblemDescriptor descriptor2 = (OfflineProblemDescriptor)userObject2;
  96       if (descriptor1.getLine() != descriptor2.getLine()) return descriptor1.getLine() - descriptor2.getLine();
  97       return descriptor1.getFQName().compareTo(descriptor2.getFQName());
  98     }
  99
 100     if (node1 instanceof RefElementNode && node2 instanceof RefElementNode){   //sort by filename and inside file by start offset
 101       return compareEntities(((RefElementNode)node1).getElement(), ((RefElementNode)node2).getElement());
 102     }
 103     if (node1 instanceof ProblemDescriptionNode && node2 instanceof ProblemDescriptionNode) {
 104       final CommonProblemDescriptor descriptor1 = ((ProblemDescriptionNode)node1).getDescriptor();
 105       final CommonProblemDescriptor descriptor2 = ((ProblemDescriptionNode)node2).getDescriptor();
 106       if (descriptor1 instanceof ProblemDescriptor && descriptor2 instanceof ProblemDescriptor) {
 107         //TODO: Do not materialise lazy pointers
 108         return ((ProblemDescriptor)descriptor1).getLineNumber() - ((ProblemDescriptor)descriptor2).getLineNumber();
 109       }
 110       if (descriptor1 != null && descriptor2 != null) {
 111         return descriptor1.getDescriptionTemplate().compareToIgnoreCase(descriptor2.getDescriptionTemplate());
 112       }
 113       if (descriptor1 == null) return descriptor2 == null ? 0 : -1;
 114       return 1;
 115     }
 116
 117     if (node1 instanceof RefElementNode && node2 instanceof ProblemDescriptionNode) {
 118       final CommonProblemDescriptor descriptor = ((ProblemDescriptionNode)node2).getDescriptor();
 119       if (descriptor instanceof ProblemDescriptor) {
 120         return compareEntity(((RefElementNode)node1).getElement(), ((ProblemDescriptor)descriptor).getPsiElement());
 121       }
 122       return compareEntities(((RefElementNode)node1).getElement(), ((ProblemDescriptionNode)node2).getElement());
 123     }
 124
 125     if (node2 instanceof RefElementNode && node1 instanceof ProblemDescriptionNode) {
 126       final CommonProblemDescriptor descriptor = ((ProblemDescriptionNode)node1).getDescriptor();
 127       if (descriptor instanceof ProblemDescriptor) {
 128         return -compareEntity(((RefElementNode)node2).getElement(), ((ProblemDescriptor)descriptor).getPsiElement());
 129       }
 130       return -compareEntities(((RefElementNode)node2).getElement(), ((ProblemDescriptionNode)node1).getElement());
 131     }
 132     if (node1 instanceof InspectionRootNode && node2 instanceof InspectionRootNode) {
 133       //TODO Dmitry Batkovich: optimization, because only one root node is existed
 134       return 0;
 135     }
 136
 137     LOG.error("node1: " + node1 + ", node2: " + node2);
 138     return 0;
 139   }
 140
 141   private static int compareEntity(final RefEntity entity, final PsiElement element) {
 142     if (entity instanceof RefElement) {
 143       final PsiElement psiElement = ((RefElement)entity).getElement();
 144       if (psiElement != null && element != null) {
 145         return PsiUtilCore.compareElementsByPosition(psiElement, element);
 146       }
 147       if (element == null) return psiElement == null ? 0 : 1;
 148     }
 149     if (element instanceof PsiQualifiedNamedElement) {
 150       return StringUtil.compare(entity.getQualifiedName(), ((PsiQualifiedNamedElement)element).getQualifiedName(), true);
 151     }
 152     if (element instanceof PsiNamedElement) {
 153       return StringUtil.compare(entity.getName(), ((PsiNamedElement)element).getName(), true);
 154     }
 155     return -1;
 156   }
 157
 158   private static int compareEntities(final RefEntity entity1, final RefEntity entity2) {
 159     if (entity1 instanceof RefElement && entity2 instanceof RefElement) {
 160       final int positionComparing = PsiUtilCore.compareElementsByPosition(((RefElement)entity1).getElement(), ((RefElement)entity2).getElement());
 161       if (positionComparing != 0) {
 162         return positionComparing;
 163       }
 164     }
 165     if (entity1 != null && entity2 != null) {
 166       final int nameComparing = entity1.getName().compareToIgnoreCase(entity2.getName());
 167       if (nameComparing != 0) {
 168         return nameComparing;
 169       }
 170       return entity1.getQualifiedName().compareToIgnoreCase(entity2.getQualifiedName());
 171     }
 172     if (entity1 != null) return -1;
 173     return entity2 != null ? 1 : 0;
 174   }
 175
 176   private static class InspectionResultsViewComparatorHolder {
 177     private static final InspectionResultsViewComparator ourInstance = new InspectionResultsViewComparator();
 178   }
 179
 180   public static InspectionResultsViewComparator getInstance() {
 181     return InspectionResultsViewComparatorHolder.ourInstance;
 182   }
 183 }