/*
* FindBugs - Find bugs in Java programs
* Copyright (C) 2003,2004 University of Maryland
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package edu.umd.cs.findbugs;
import java.util.Iterator;
import java.util.NoSuchElementException;
import edu.umd.cs.findbugs.model.ClassNameRewriter;
import edu.umd.cs.findbugs.model.ClassNameRewriterUtil;
import edu.umd.cs.findbugs.model.IdentityClassNameRewriter;
/**
* Compare bug instances by only those criteria which we would expect to
* remain constant between versions.
*/
public class VersionInsensitiveBugComparator implements WarningComparator {
private ClassNameRewriter classNameRewriter = IdentityClassNameRewriter.instance();
private boolean exactBugPatternMatch = true;
private boolean comparePriorities = false;
public VersionInsensitiveBugComparator() {
}
public void setClassNameRewriter(ClassNameRewriter classNameRewriter) {
this.classNameRewriter = classNameRewriter;
}
public void setComparePriorities(boolean b) {
comparePriorities = b;
}
/**
* Wrapper for BugAnnotation iterators, which filters out
* annotations we don't care about.
*/
private class FilteringAnnotationIterator implements Iterator<BugAnnotation> {
private Iterator<BugAnnotation> iter;
private BugAnnotation next;
public FilteringAnnotationIterator(Iterator<BugAnnotation> iter) {
this.iter = iter;
this.next = null;
}
public boolean hasNext() {
findNext();
return next != null;
}
public BugAnnotation next() {
findNext();
if (next == null)
throw new NoSuchElementException();
BugAnnotation result = next;
next = null;
return result;
}
public void remove() {
throw new UnsupportedOperationException();
}
private void findNext() {
while (next == null) {
if (!iter.hasNext())
break;
BugAnnotation candidate = iter.next();
if (!isBoring(candidate)) {
next = candidate;
break;
}
}
}
}
private boolean isBoring(BugAnnotation annotation) {
return !(annotation instanceof LocalVariableAnnotation || annotation.isSignificant());
}
private static int compareNullElements(Object a, Object b) {
if (a != null)
return 1;
else if (b != null)
return -1;
else
return 0;
}
private static String getCode(String pattern) {
int sep = pattern.indexOf('_');
if (sep < 0)
return "";
return pattern.substring(0, sep);
}
private void dump(BugInstance bug) {
System.out.println(bug.getMessage());
Iterator<BugAnnotation> i = bug.annotationIterator();
while (i.hasNext()) {
System.out.println(" " + i.next());
}
}
public int compare(BugInstance lhs, BugInstance rhs) {
// Attributes of BugInstance.
// Compare abbreviation
// Compare class and method annotations (ignoring line numbers).
// Compare field annotations.
int cmp;
BugPattern lhsPattern = lhs.getBugPattern();
BugPattern rhsPattern = rhs.getBugPattern();
if (lhsPattern == null || rhsPattern == null) {
// One of the patterns is missing.
// However, we can still accurately match by abbrev (usually) by comparing
// the part of the type before the first '_' character.
// This is almost always equivalent to the abbrev.
String lhsCode = getCode(lhs.getType());
String rhsCode = getCode(rhs.getType());
if ((cmp = lhsCode.compareTo(rhsCode)) != 0) {
return cmp;
}
} else {
// Compare by abbrev instead of type. The specific bug type can change
// (e.g., "definitely null" to "null on simple path"). Also, we often
// change bug pattern types from one version of FindBugs to the next.
//
// Source line and field name are still matched precisely, so this shouldn't
// cause loss of precision.
if ((cmp = lhsPattern.getAbbrev().compareTo(rhsPattern.getAbbrev())) != 0)
return cmp;
if (isExactBugPatternMatch() && (cmp = lhsPattern.getType().compareTo(rhsPattern.getType())) != 0)
return cmp;
}
if (comparePriorities) {
cmp = lhs.getPriority() - rhs.getPriority();
if (cmp != 0) return cmp;
}
Iterator<BugAnnotation> lhsIter = new FilteringAnnotationIterator(lhs.annotationIterator());
Iterator<BugAnnotation> rhsIter = new FilteringAnnotationIterator(rhs.annotationIterator());
annotationLoop:
while (lhsIter.hasNext() && rhsIter.hasNext()) {
BugAnnotation lhsAnnotation = lhsIter.next();
BugAnnotation rhsAnnotation = rhsIter.next();
Class<? extends BugAnnotation> lhsClass;
while (true) {
// Different annotation types obviously cannot be equal,
// so just compare by class name.
lhsClass = lhsAnnotation.getClass();
Class<? extends BugAnnotation> rhsClass = rhsAnnotation.getClass();
if (lhsClass == rhsClass) break;
if (lhsClass == LocalVariableAnnotation.class && !((LocalVariableAnnotation)lhsAnnotation).isSignificant() && lhsIter.hasNext())
lhsAnnotation = lhsIter.next();
else if (rhsClass == LocalVariableAnnotation.class && !((LocalVariableAnnotation)rhsAnnotation).isSignificant() && rhsIter.hasNext())
rhsAnnotation = rhsIter.next();
else
return lhsClass.getName().compareTo(rhsClass.getName());
}
if (lhsClass == ClassAnnotation.class) {
// ClassAnnotations should have their class names rewritten to
// handle moved and renamed classes.
String lhsClassName = classNameRewriter.rewriteClassName(
((ClassAnnotation)lhsAnnotation).getClassName());
String rhsClassName = classNameRewriter.rewriteClassName(
((ClassAnnotation)rhsAnnotation).getClassName());
cmp = lhsClassName.compareTo(rhsClassName);
} else if(lhsClass == MethodAnnotation.class ) {
// Rewrite class names in MethodAnnotations
MethodAnnotation lhsMethod = ClassNameRewriterUtil.convertMethodAnnotation(
classNameRewriter, (MethodAnnotation) lhsAnnotation);
MethodAnnotation rhsMethod = ClassNameRewriterUtil.convertMethodAnnotation(
classNameRewriter, (MethodAnnotation) rhsAnnotation);
cmp = lhsMethod.compareTo(rhsMethod);
} else if(lhsClass == FieldAnnotation.class) {
// Rewrite class names in FieldAnnotations
FieldAnnotation lhsField = ClassNameRewriterUtil.convertFieldAnnotation(
classNameRewriter, (FieldAnnotation) lhsAnnotation);
FieldAnnotation rhsField = ClassNameRewriterUtil.convertFieldAnnotation(
classNameRewriter, (FieldAnnotation) rhsAnnotation);
cmp = lhsField.compareTo(rhsField);
} else if(lhsClass == StringAnnotation.class) {
String lhsString = ((StringAnnotation)lhsAnnotation).getValue();
String rhsString = ((StringAnnotation)rhsAnnotation).getValue();
cmp = lhsString.compareTo(rhsString);
} else if(lhsClass == LocalVariableAnnotation.class) {
String lhsName = ((LocalVariableAnnotation)lhsAnnotation).getName();
String rhsName = ((LocalVariableAnnotation)rhsAnnotation).getName();
if (lhsName.equals("?") || rhsName.equals("?"))
continue;
cmp = lhsName.compareTo(rhsName);
} else if(lhsClass == TypeAnnotation.class) {
String lhsType = ((TypeAnnotation)lhsAnnotation).getTypeDescriptor();
String rhsType = ((TypeAnnotation)rhsAnnotation).getTypeDescriptor();
lhsType = ClassNameRewriterUtil.rewriteSignature(classNameRewriter, lhsType);
rhsType = ClassNameRewriterUtil.rewriteSignature(classNameRewriter, rhsType);
cmp = lhsType.compareTo(rhsType);
} else if(lhsClass == IntAnnotation.class) {
int lhsValue = ((IntAnnotation)lhsAnnotation).getValue();
int rhsValue = ((IntAnnotation)rhsAnnotation).getValue();
cmp = lhsValue - rhsValue;
} else if (isBoring(lhsAnnotation)) {
throw new IllegalStateException("Impossible");
} else
throw new IllegalStateException("Unknown annotation type: " +lhsClass.getName());
if (cmp != 0)
return cmp;
}
if (interestingNext(rhsIter))
return -1;
else if (interestingNext(lhsIter))
return 1;
else
return 0;
}
private boolean interestingNext(Iterator<BugAnnotation> i) {
while (i.hasNext()) {
BugAnnotation a = i.next();
if (isBoring(a))
continue;
if (!(a instanceof LocalVariableAnnotation))
return true;
if (((LocalVariableAnnotation)a).isSignificant())
return true;
}
return false;
}
/**
* @param exactBugPatternMatch The exactBugPatternMatch to set.
*/
public void setExactBugPatternMatch(boolean exactBugPatternMatch) {
this.exactBugPatternMatch = exactBugPatternMatch;
}
/**
* @return Returns the exactBugPatternMatch.
*/
public boolean isExactBugPatternMatch() {
return exactBugPatternMatch;
}
}
// vim:ts=4