Changeset 1127 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeComparator.java

Timestamp:

03/18/13 11:54:15 (11 years ago)

Author:

pharms

Message:

• complete refactoring of task detection
• many performance improvements in task detection
• improved merging of sequences using Myers diff algorithm

File:

• trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeComparator.java (modified) (4 diffs)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeComparator.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
 
+import java.util.HashMap;
+
 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
@@ -44 +46 @@
     private NodeEquality minimalNodeEquality;
 
-
+    private Comparer comparer;
+
+    private Comparer lexicalComparer;
+
+    private StopWatch stopWatch = new StopWatch();
+    
+    private HashMap<Long, Boolean> equalityBuffer = new HashMap<Long, Boolean>();
+
+    private HashMap<Long, Boolean> lexicalEqualityBuffer;
 
     /**
@@ -60 +70 @@
         this.nodeEqualityRuleManager = nodeEqualityRuleManager;
         this.minimalNodeEquality = minimalNodeEquality;
-    }
-
-
+        
+        if (minimalNodeEquality == NodeEquality.LEXICALLY_EQUAL) {
+            comparer = new LexicalComparer();
+        }
+        else if (minimalNodeEquality == NodeEquality.SYNTACTICALLY_EQUAL) {
+            comparer = new SyntacticalComparer();
+        }
+        else if (minimalNodeEquality == NodeEquality.SEMANTICALLY_EQUAL) {
+            comparer = new SemanticalComparer();
+        }
+        else {
+            comparer = new DefaultComparer();
+        }
+        
+        if (minimalNodeEquality == NodeEquality.LEXICALLY_EQUAL) {
+            lexicalComparer = comparer;
+            lexicalEqualityBuffer = equalityBuffer;
+        }
+        else {
+            lexicalComparer = new LexicalComparer();
+            lexicalEqualityBuffer = new HashMap<Long, Boolean>();
+        }
+    }
 
     /* (non-Javadoc)
@@ -69 +99 @@
     @Override
     public boolean equals(ITaskTreeNode symbol1, ITaskTreeNode symbol2) {
-        return nodeEqualityRuleManager.applyRules(symbol1, symbol2).isAtLeast(minimalNodeEquality);
-    }
-
+        //String id = "compare " + symbol1.getClass().getSimpleName() + " " +
+        //    symbol2.getClass().getSimpleName();
+        //String id = "compare";
+        //stopWatch.start(id);
+        
+        Boolean result;
+        
+        if (symbol1 != symbol2) {
+            long key = ((long) System.identityHashCode(symbol1)) << 32;
+            key += System.identityHashCode(symbol2);
+            
+            result = equalityBuffer.get(key);
+            
+            if (result == null) {
+                result = comparer.compare(symbol1, symbol2);
+                equalityBuffer.put(key, result);
+            }
+        }
+        else {
+            result = true;
+        }
+        //stopWatch.stop(id);
+        
+        /*boolean result2 = nodeEqualityRuleManager.areAtLeastEqual(symbol1, symbol2, minimalNodeEquality);
+        if (result != result2) {
+            throw new IllegalStateException("implementation error");
+        }*/
+        
+        return result;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @return
+     */
+    StopWatch getStopWatch() {
+        return stopWatch;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param node1
+     * @param node2
+     * @return
+     */
+    boolean areLexicallyEqual(ITaskTreeNode symbol1, ITaskTreeNode symbol2) {
+        Boolean result;
+        
+        if (symbol1 != symbol2) {
+            long key = ((long) System.identityHashCode(symbol1)) << 32;
+            key += System.identityHashCode(symbol2);
+            
+            result = lexicalEqualityBuffer.get(key);
+            
+            if (result == null) {
+                result = lexicalComparer.compare(symbol1, symbol2);
+                lexicalEqualityBuffer.put(key, result);
+            }
+        }
+        else {
+            result = true;
+        }
+        
+        return result;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @return
+     */
+    NodeEquality getConsideredNodeEquality() {
+        return minimalNodeEquality;
+    }
+
+    /**
+     * 
+     */
+    private interface Comparer {
+        /**
+         * 
+         */
+        boolean compare(ITaskTreeNode node1, ITaskTreeNode node2);
+    }
+
+    /**
+     * 
+     */
+    private class LexicalComparer implements Comparer {
+        
+        /**
+         * 
+         */
+        public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+            return nodeEqualityRuleManager.areLexicallyEqual(node1, node2);
+        }
+    }
+
+    /**
+     * 
+     */
+    private class SyntacticalComparer implements Comparer {
+        
+        /**
+         * 
+         */
+        public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+            return nodeEqualityRuleManager.areSyntacticallyEqual(node1, node2);
+        }
+    }
+
+    /**
+     * 
+     */
+    private class SemanticalComparer implements Comparer {
+        
+        /**
+         * 
+         */
+        public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+            return nodeEqualityRuleManager.areSemanticallyEqual(node1, node2);
+        }
+    }
+
+    /**
+     * 
+     */
+    private class DefaultComparer implements Comparer {
+        
+        /**
+         * 
+         */
+        public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+            return nodeEqualityRuleManager.areAtLeastEqual(node1, node2, minimalNodeEquality);
+        }
+    }
 }