Changeset 807 for trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRule.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/IterationComparisonRule.java (modified) (5 diffs)

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

@@ -41 +41 @@
  *   </tr>
  *   <tr>
+ *     <td>an iteration with a selection of syntactically equal children</td>
+ *     <td>an iteration with a selection of syntactically equal children that are all syntactically
+ *     equal to the selection of children of iteration 1</td>
+ *     <td><code>NodeEquality.SYNTACTICALLY_EQUAL</code></td>
+ *   </tr>
+ *   <tr>
  *     <td>an iteration with a selection of semantically equal children</td>
  *     <td>an iteration with a child that is semantically equal to the children of the child
  *     selection of iteration 1</td>
+ *     <td><code>NodeEquality.SEMANTICALLY_EQUAL</code></td>
+ *   </tr>
+ *   <tr>
+ *     <td>an iteration with a selection of semantically equal children</td>
+ *     <td>an iteration with a selection of semantically equal children that are all semantically
+ *     equal to the selection of children of iteration 1</td>
  *     <td><code>NodeEquality.SEMANTICALLY_EQUAL</code></td>
  *   </tr>
@@ -80 +92 @@
         }
 
+        if (node1 == node2) {
+            return NodeEquality.IDENTICAL;
+        }
+
         // if both iterations do not have children, they are equal although this doesn't make sense
         if ((node1.getChildren().size() == 0) && (node2.getChildren().size() == 0)) {
-            return NodeEquality.IDENTICAL;
+            return NodeEquality.LEXICALLY_EQUAL;
+        }
+        else if ((node1.getChildren().size() == 0) || (node2.getChildren().size() == 0)) {
+            return NodeEquality.UNEQUAL;
         }
 
@@ -102 +121 @@
 
         if (nodeEquality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)) {
-            return nodeEquality;
+            // prevent, that identical is returned, because the iterations itself are not identical
+            // although the iterated tasks are
+            if (nodeEquality == NodeEquality.IDENTICAL) {
+                return NodeEquality.LEXICALLY_EQUAL;
+            }
+            else {
+                return nodeEquality;
+            }
         }
 
@@ -115 +141 @@
     /**
      * <p>
-     * compares two task tree nodes. One of them must be a selection of at least semantically
-     * equal children. The other one can be any task tree node. The method returns a node equality
-     * that is not <code>NodeEquality.UNEQUAL</code> if the other node is at least semantically
-     * equal to the children of the selection. It returns more concrete equalities, if the
-     * equality between the other node and the children of the selection is more concrete.
+     * compares two task tree nodes. One of them must be a selection, the other one can be any task
+     * tree node. The method returns a node equality that is not <code>NodeEquality.UNEQUAL</code>
+     * if the other node is at least semantically equal to the children of the selection. It
+     * returns more concrete equalities, if the equality between the other node and the children
+     * of the selection is more concrete.
      * </p> 
      * 
@@ -144 +170 @@
         }
 
-        NodeEquality lessConcreteEqualityForAllComparisons = NodeEquality.IDENTICAL;
+        // Iterations, where one has a selection and the other one not can at most be syntactically
+        // equal but not identical
+        NodeEquality commonDenominatorForAllComparisons = NodeEquality.SYNTACTICALLY_EQUAL;
 
         for (ITaskTreeNode child : selection.getChildren()) {
             NodeEquality nodeEquality = mRuleManager.applyRules(node, child);
 
-            if (!nodeEquality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)) {
+            if ((nodeEquality == null) || (nodeEquality == NodeEquality.UNEQUAL))
+            {
                 return NodeEquality.UNEQUAL;
             }
-            else if (!lessConcreteEqualityForAllComparisons.isAtLeast(nodeEquality)) {
-                lessConcreteEqualityForAllComparisons = nodeEquality;
-            }
+            
+            commonDenominatorForAllComparisons =
+                commonDenominatorForAllComparisons.getCommonDenominator(nodeEquality);
         }
 
-        return lessConcreteEqualityForAllComparisons;
+        return commonDenominatorForAllComparisons;
     }