Add computation of deltas (differences between Analysis runs).

[cfb.git] / prod / net / jaekl / cfb / xml / BugInstance.java

diff --git a/prod/net/jaekl/cfb/xml/BugInstance.java b/prod/net/jaekl/cfb/xml/BugInstance.java
index 3386e3f70fd2d47da0d820e174c617f5592e73b5..100251f9e9a37fce9235b30beb1492ebec24adc3 100644 (file)
--- a/prod/net/jaekl/cfb/xml/BugInstance.java
+++ b/prod/net/jaekl/cfb/xml/BugInstance.java
@@ -7,6 +7,7 @@ import java.util.List;
 
 import org.xml.sax.Attributes;
 
+import net.jaekl.cfb.util.Util;
 import net.jaekl.qd.xml.MissingAttributeException;
 import net.jaekl.qd.xml.ParseResult;
 import net.jaekl.qd.xml.XmlParseException;
@@ -115,4 +116,77 @@ public class BugInstance extends ParseResult {
                        sl.dump(pw, childIndent);
                }
        }
+       
+       // Note that this is a heuristic, "fuzzy", equals.
+       // Two BugInstances will be considered equal if:
+       //   - they refer to the same bug type
+       //   - they took place in the same class and method
+       //   - the variable names referred to (if any) match
+       // In particular, this equality test does not check 
+       // for line numbers being equal.  This is by design;
+       // we want to consider two bugs to be the "same bug" 
+       // even if other changes in the file have shifted 
+       // line numbers a bit.
+       @Override
+       public boolean equals(Object obj) 
+       {
+               if (null == obj) { 
+                       return false;
+               }
+               if (obj instanceof BugInstance) {
+                       BugInstance that = (BugInstance)obj;
+                       
+                       if (! Util.objsAreEqual(this.m_type, that.m_type)) {
+                               return false;
+                       }
+                       
+                       if (! Util.objsAreEqual(this.m_category, that.m_category)) {
+                               return false;
+                       }
+
+                       BugMethod thisMethod = this.getPrincipalMethod();
+                       BugMethod thatMethod = that.getPrincipalMethod();
+                       if (null == thisMethod) {
+                               if (null == thatMethod) {
+                                       return false;
+                               }
+                       }
+                       else {
+                               if (! Util.objsAreEqual(thisMethod.getClassName(), thatMethod.getClassName())) {
+                                       return false;
+                               }
+                               if (! Util.objsAreEqual(thisMethod.getMethodName(), thatMethod.getMethodName())) {
+                                       return false;
+                               }
+                       }
+                       
+                       if (! Util.objsAreEqual(this.getVariables(), that.getVariables())) {
+                               return false;
+                       }
+                       
+                       return true;
+               }
+               return false;
+       }
+       
+       @Override
+       public int hashCode() 
+       {
+               int code = Util.objHashCode(m_type)
+                                * Util.objHashCode(m_category)
+                                * Util.objHashCode(getPrincipalMethod())
+                                * Util.objHashCode(getVariables());
+               return code;
+       }
+       
+       // Get the "principal" method.
+       // This should be the place where the bug is reported.
+       BugMethod getPrincipalMethod()
+       {
+               List<BugMethod> bugMethods = getMethods();
+               if ((null == bugMethods) || (0 == bugMethods.size())) {
+                       return null;
+               }
+               return bugMethods.get(0);
+       }
 }