Changeset 1125 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java

Timestamp:

03/18/13 11:46:47 (11 years ago)

Author:

pharms

Message:

• refactoring of task tree node comparison to be able to optimize the comparisons for the different comparison levels lexically, syntactically, semantically

File:

• trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java (modified) (9 diffs)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java

@@ -14 +14 @@
 
 package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import java.util.List;
 
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
@@ -33 +35 @@
     /** the rule manager for internally comparing task tree nodes */
     private NodeEqualityRuleManager mRuleManager;
-
+    
     /**
      * <p>
@@ -47 +49 @@
     }
 
-    /*
-     * (non-Javadoc)
-     * 
-     * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+    /* (non-Javadoc)
+     * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode)
+     */
+    @Override
+    public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) {
+        return ((node1 instanceof ISelection) && (!(node2 instanceof ISelection))) ||
+               ((node2 instanceof ISelection) && (!(node1 instanceof ISelection)));
+    }
+
+    /* (non-Javadoc)
+     * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode)
+     */
+    @Override
+    public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
+        NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL);
+        return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
+    }
+
+    /* (non-Javadoc)
+     * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode)
+     */
+    @Override
+    public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
+        NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL);
+        return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
+    }
+
+    /* (non-Javadoc)
+     * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode)
+     */
+    @Override
+    public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
+        NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL);
+        return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
+    }
+
+    /* (non-Javadoc)
+     * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode)
      */
     @Override
     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+        return getEquality(node1, node2, null);
+    }
+    
+    /**
+     * 
+     */
+    private NodeEquality getEquality(ITaskTreeNode node1,
+                                     ITaskTreeNode node2,
+                                     NodeEquality  requiredEqualityLevel)
+    {
         ISelection selection = null;
         ITaskTreeNode node = null;
@@ -59 +105 @@
         if (node1 instanceof ISelection) {
             if (node2 instanceof ISelection) {
-                // the rule is not responsible for two iterations
+                // the rule is not responsible for two selections
                 return null;
             }
@@ -68 +114 @@
         else if (node2 instanceof ISelection) {
             if (node1 instanceof ISelection) {
-                // the rule is not responsible for two iterations
+                // the rule is not responsible for two selections
                 return null;
             }
@@ -79 +125 @@
         }
 
-        // now, that we found the iteration and the node, lets compare the child of the iteration
+        // now, that we found the selection and the node, lets compare the children of the selection
         // with the node.
-        if (selection.getChildren().size() < 1) {
+        List<ITaskTreeNode> children = selection.getChildren();
+        
+        if (children.size() < 1) {
             return null;
         }
@@ -87 +135 @@
         NodeEquality mostConcreteNodeEquality = null;
         
-        for (ITaskTreeNode child : selection.getChildren()) {
-            NodeEquality nodeEquality = mRuleManager.applyRules(child, node);
+        for (ITaskTreeNode child : children) {
+            NodeEquality nodeEquality = callRuleManager(child, node, requiredEqualityLevel);
             
             if (nodeEquality != NodeEquality.UNEQUAL) {
@@ -94 +142 @@
                     mostConcreteNodeEquality = nodeEquality;
                 }
-                else {
-                    mostConcreteNodeEquality =
-                        mostConcreteNodeEquality.getCommonDenominator(nodeEquality);
+                else if (mostConcreteNodeEquality.isAtLeast(nodeEquality)) {
+                    mostConcreteNodeEquality = nodeEquality;
+                    
+                }
+                
+                if ((requiredEqualityLevel != null) &&
+                    (mostConcreteNodeEquality.isAtLeast(requiredEqualityLevel)))
+                {
+                    // if we found one child of the selection that is as equal as required, then
+                    // we can consider the selection to be sufficiently equal to the other node.
+                    // So we break up checking further children.
+                    break;
                 }
             }
@@ -111 +168 @@
 
     }
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param child1
+     * @param child2
+     * @param requiredEqualityLevel
+     * @return
+     */
+    private NodeEquality callRuleManager(ITaskTreeNode child1,
+                                         ITaskTreeNode child2,
+                                         NodeEquality  requiredEqualityLevel)
+    {
+        if (requiredEqualityLevel == null) {
+            return mRuleManager.compare(child1, child2);
+        }
+        else if (mRuleManager.areAtLeastEqual(child1, child2, requiredEqualityLevel)) {
+            return requiredEqualityLevel;
+        }
+        else {
+            return NodeEquality.UNEQUAL;
+        }
+    }
 }