Changeset 390 for trunk/EventBenchConsole

Timestamp:

02/20/12 11:54:55 (13 years ago)

Author:

sherbold

Message:

• all hashValues are now only computed once, stored and only recomputed when something changes.
• de.ugoe.cs.eventbench.jfc.data.JFCTargetComparator now allows precomputation of equalities

Location:

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/data

Files:

• JFCEvent.java (modified) (4 diffs)
• JFCTargetComparator.java (modified) (7 diffs)

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/data/JFCEvent.java

@@ -45 +45 @@
          */
         private Map<String, String> parentParameters;
+        
+        private boolean targetChanged = false;
+        
+        private int targetHash = -1;
 
         /**
@@ -145 +149 @@
                         target += "." + extension;
                 }
+                targetChanged = true;
         }
 
@@ -187 +192 @@
         @Override
         protected int targetHashCode() {
-                int hashCode = 0;
-                int multiplier = 29;
-                if (target != null) {
-                        String[] targetParts = target.split("\\]\\.\\[");
-                        if (targetParts.length == 0) {
-                                hashCode = widgetHashCode(target);
-                        } else {
-                                for (String widgetString : targetParts) {
-                                        hashCode = hashCode * multiplier
-                                                        + widgetHashCode(widgetString);
+                if( targetChanged || targetHash==-1 ) {
+                        targetHash = 0;
+                        int multiplier = 29;
+                        if (target != null) {
+                                String[] targetParts = target.split("\\]\\.\\[");
+                                if (targetParts.length == 0) {
+                                        targetHash = widgetHashCode(target);
+                                } else {
+                                        for (String widgetString : targetParts) {
+                                                targetHash = targetHash * multiplier
+                                                                + widgetHashCode(widgetString);
+                                        }
                                 }
                         }
+                        targetChanged = false;
                 }
-
-                return hashCode;
+                return targetHash;
         }
 
@@ -221 +228 @@
                         hashCode = hashCode * multiplier + widgetInfo[1].hashCode();
                         hashCode = hashCode * multiplier + widgetInfo[2].hashCode();
-                        hashCode = hashCode * multiplier + widgetInfo[3].hashCode();
+                        //hashCode = hashCode * multiplier + widgetInfo[3].hashCode();
                 }
                 return hashCode;

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/data/JFCTargetComparator.java

@@ -2 +2 @@
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+
+import org.apache.commons.collections15.CollectionUtils;
 
 /**
@@ -18 +23 @@
  */
 public class JFCTargetComparator {
+        
+        private static boolean mutable = true;
+        
+        private static Set<String> knownTargets = new LinkedHashSet<String>();
+        
+        private static Map<String, Set<String>> equalTargets;
+        
+        public static void setMutable(boolean mutable) {
+                if( JFCTargetComparator.mutable==true && mutable == false ) {
+                        equalTargets = new HashMap<String, Set<String>>();
+                        for( String target1 : knownTargets ) {
+                                Set<String> curEqualTargets = new HashSet<String>();
+                                for( String target2 : knownTargets ) {
+                                        if( compare(target1, target2) ) {
+                                                curEqualTargets.add(target2);
+                                        }
+                                }
+                                equalTargets.put(target1, curEqualTargets);
+                        }
+                }
+                JFCTargetComparator.mutable = mutable;
+        }
 
         /**
@@ -41 +68 @@
          */
         public static boolean compare(String target1, String target2) {
-                instance.addTarget(target1);
-                instance.addTarget(target2);
-
-                JFCWidget widget1 = instance.find(target1);
-                JFCWidget widget2 = instance.find(target2);
-
-                return widget1 == widget2;
+                boolean result = false;
+                if( mutable ) {
+                        instance.addTarget(target1);
+                        instance.addTarget(target2);
+                        knownTargets.add(target1);
+                        knownTargets.add(target2);
+                        JFCWidget widget1 = instance.find(target1);
+                        JFCWidget widget2 = instance.find(target2);
+                        result = (widget1==widget2);
+                }
+                
+                
+                if( !mutable ) {
+                        Set<String> curEquals = equalTargets.get(target1);
+                        if( curEquals!=null ) {
+                                result = curEquals.contains(target2);
+                        }                       
+                }
+                
+                return result;
         }
 
@@ -287 +327 @@
                  */
                 String text;
+                
+                int hashCode=0;
 
                 /**
@@ -309 +351 @@
                         if (obj instanceof JFCWidget) {
                                 JFCWidget other = (JFCWidget) obj;
+                                
+                                
+                                boolean titleEqual = CollectionUtils.containsAny(titles, other.titles);
+                                boolean hashEqual = CollectionUtils.containsAny(hashCodes, other.hashCodes);
+                                
+                                /*
                                 Set<String> titlesCopy = new LinkedHashSet<String>(titles);
                                 Set<String> hashCodesCopy = new LinkedHashSet<String>(hashCodes);
 
                                 titlesCopy.retainAll(other.titles);
-                                hashCodesCopy.retainAll(other.hashCodes);
+                                hashCodesCopy.retainAll(other.hashCodes);*/
 
                                 boolean retVal;
+                                
+                                if (widgetClass.equals("Class")) {
+                                        retVal = (widgetClass.equals(other.widgetClass)
+                                                        && text.equals(other.text) && (titleEqual || hashEqual));
+                                } else {
+                                        retVal = (widgetClass.equals(other.widgetClass)
+                                                        && index.equals(other.index)
+                                                        && text.equals(other.text) && (titleEqual || hashEqual));
+                                }
+                                /*
                                 if (widgetClass.equals("Class")) {
                                         retVal = (widgetClass.equals(other.widgetClass)
@@ -325 +383 @@
                                                         && text.equals(other.text) && (!titlesCopy
                                                         .isEmpty() || !hashCodesCopy.isEmpty()));
-                                }
+                                }*/
                                 return retVal;
                         }
@@ -338 +396 @@
                 @Override
                 public int hashCode() {
-                        int multiplier = 7;
-                        int hashCode = 0;
-                        hashCode = multiplier * hashCode + widgetClass.hashCode();
-                        if (!widgetClass.equals("Class")) {
-                                hashCode = multiplier * hashCode + index.hashCode();
-                        }
-                        hashCode = multiplier * hashCode + text.hashCode();
+                        if( hashCode==0 ) {
+                                int multiplier = 7;
+                                hashCode = multiplier * hashCode + widgetClass.hashCode();
+                                if (!widgetClass.equals("Class")) {
+                                        hashCode = multiplier * hashCode + index.hashCode();
+                                }
+                                hashCode = multiplier * hashCode + text.hashCode();
+                        }
                         return hashCode;
                 }