Changeset 807 for trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRule.java

Timestamp:

09/11/12 16:45:51 (12 years ago)

Author:

pharms

Message:

• improved node equality comparison to match the principle of lexical, syntactical and semantical node equality. As a result, more condensed task trees are created.

File:

• trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRule.java (modified) (2 diffs)

trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRule.java

@@ -7 +7 @@
  * <p>
  * this node comparison rule is capable of comparing selections. If both selections do not have
- * children, they are treated as lexically equal. If they have the same number of children other
- * than 0 and all these children are lexically equal, then the selections are lexically equal.
- * They are syntactically equal, if each child of both selections is syntactically equal to any
- * other child. The rule can not compare semantical equality if the nodes are not at least
- * syntactically equal and returns null, if it can not decide this.
+ * children, they are treated as identical. If they have children, each child of both selections
+ * is compared to each child of the respective other selection. The resulting equality is the most
+ * concrete one of all these comparisons. I.e. if all children are at least lexically equal, then
+ * the selections are lexically equal. If all children are at least syntactically equal, then the
+ * selections are syntactically equal. If all children are at least semantically equal, then the
+ * selections are semantically equal. If only one of the selections has children, then the
+ * selections are unequal.
  * </p>
  * 
@@ -46 +48 @@
         }
 
-        // if both sequences do not have children, they are equal although this doesn't make sense
+        if (node1 == node2) {
+            return NodeEquality.IDENTICAL;
+        }
+
+        // if both sequences do not have children, they are identical. If only one of them has
+        // children, they are unequal.
         if ((node1.getChildren().size() == 0) && (node2.getChildren().size() == 0)) {
             return NodeEquality.LEXICALLY_EQUAL;
         }
+        else if ((node1.getChildren().size() == 0) || (node2.getChildren().size() == 0)) {
+            return NodeEquality.UNEQUAL;
+        }
 
-        // Selections are syntactically equal, if they have children, which are all syntactically
-        // equal.
-        // They are lexically equals, if they have the same number and order of lexically equal
-        // children
-        boolean lexicallyEqual = node1.getChildren().size() == node2.getChildren().size();
+        NodeEquality selectionEquality = NodeEquality.LEXICALLY_EQUAL;
 
-        for (int i = 0; i < node1.getChildren().size(); i++) {
-            ITaskTreeNode child1 = node1.getChildren().get(i);
-            boolean foundLexicallyEqualChild = false;
-
-            for (int j = 0; j < node2.getChildren().size(); j++) {
-                ITaskTreeNode child2 = node2.getChildren().get(j);
-
-                NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2);
-
-                if (!nodeEquality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) {
-                    return null;
-                }
-                else if (nodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)) {
-                    foundLexicallyEqualChild = true;
+        // compare each child of selection one with each child of selection two
+        NodeEquality childEquality;
+        NodeEquality currentEquality;
+        for (ITaskTreeNode child1 : node1.getChildren()) {
+            childEquality = null;
+            for (ITaskTreeNode child2 : node2.getChildren()) {
+                currentEquality = mRuleManager.applyRules(child1, child2);
+                if ((currentEquality != null) && (currentEquality != NodeEquality.UNEQUAL)) {
+                    if (childEquality == null) {
+                        childEquality = currentEquality;
+                    }
+                    else {
+                        childEquality = childEquality.getCommonDenominator(currentEquality);
+                    }
                 }
             }
-
-            // if we compare two children at the same position and if they are lexically equal
-            // then it can be further expected, that the selections are lexically equal
-            lexicallyEqual &= foundLexicallyEqualChild;
+            
+            if (childEquality != null) {
+                selectionEquality = selectionEquality.getCommonDenominator(childEquality);
+            }
+            else {
+                return NodeEquality.UNEQUAL;
+            }
         }
 
-        if (lexicallyEqual) {
-            return NodeEquality.LEXICALLY_EQUAL;
+        // compare each child of selection two with each child of selection one
+        for (ITaskTreeNode child2 : node2.getChildren()) {
+            childEquality = null;
+            for (ITaskTreeNode child1 : node1.getChildren()) {
+                currentEquality = mRuleManager.applyRules(child1, child2);
+                if ((currentEquality != null) && (currentEquality != NodeEquality.UNEQUAL)) {
+                    if (childEquality == null) {
+                        childEquality = currentEquality;
+                    }
+                    else {
+                        childEquality = childEquality.getCommonDenominator(currentEquality);
+                    }
+                }
+            }
+            
+            if (childEquality != null) {
+                selectionEquality = selectionEquality.getCommonDenominator(childEquality);
+            }
+            else {
+                return NodeEquality.UNEQUAL;
+            }
         }
-        else {
-            return NodeEquality.SYNTACTICALLY_EQUAL;
-        }
+
+        return selectionEquality;
     }
+
 }