Changeset 807 for trunk/quest-core-tasktrees/src/main/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.

Location:

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

Files:

• EventTaskComparisonRule.java (added)
• GUIEventTaskComparisonRule.java (added)
• IterationComparisonRule.java (modified) (5 diffs)
• NodeEquality.java (modified) (1 diff)
• NodeEqualityRuleManager.java (modified) (1 diff)
• NodeIdentityRule.java (modified) (1 diff)
• SelectionComparisonRule.java (modified) (2 diffs)
• SequenceComparisonRule.java (modified) (3 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;
     }
 

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

@@ -90 +90 @@
         }
     }
+
+    /**
+     * <p>
+     * returns the common denominator of this node equality and the provided one. I.e. if one
+     * equality is e.g. syntactical and the other one only semantical, then semantical is returned.
+     * </p>
+     *
+     * @param equality the equality, to compare this with
+     * @return
+     */
+    public NodeEquality getCommonDenominator(NodeEquality otherEquality) {
+        if (this.isAtLeast(otherEquality)) {
+            return otherEquality;
+        }
+        else if (otherEquality.isAtLeast(this)) {
+            return this;
+        }
+        else {
+            return NodeEquality.UNEQUAL;
+        }
+    }
 }

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

@@ -33 +33 @@
         mRuleIndex = new ArrayList<NodeComparisonRule>();
         mRuleIndex.add(new NodeIdentityRule());
+        mRuleIndex.add(new GUIEventTaskComparisonRule());
+        mRuleIndex.add(new EventTaskComparisonRule());
         mRuleIndex.add(new IterationComparisonRule(this));
         mRuleIndex.add(new SequenceComparisonRule(this));

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

@@ -22 +22 @@
     @Override
     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
-        if ((node1 == node2) || ((node1 != null) && (node1.equals(node2)))) {
+        if (node1 == node2) {
             return NodeEquality.IDENTICAL;
         }

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;
     }
+
 }

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

@@ -44 +44 @@
         }
 
+        if (node1 == node2) {
+            return NodeEquality.IDENTICAL;
+        }
+
         // if both sequences do not have children, they are equal although this doesn't make sense
         if ((node1.getChildren().size() == 0) && (node2.getChildren().size() == 0)) {
@@ -49 +53 @@
         }
 
-        // 
         if (node1.getChildren().size() != node2.getChildren().size()) {
-            return null;
+            return NodeEquality.UNEQUAL;
         }
 
+        NodeEquality resultingEquality = NodeEquality.LEXICALLY_EQUAL;
         for (int i = 0; i < node1.getChildren().size(); i++) {
             ITaskTreeNode child1 = node1.getChildren().get(i);
@@ -60 +64 @@
             NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2);
 
-            if (!nodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)) {
-                return null;
+            if ((nodeEquality == null) || (nodeEquality == NodeEquality.UNEQUAL)) {
+                return NodeEquality.UNEQUAL;
             }
+            
+            resultingEquality = resultingEquality.getCommonDenominator(nodeEquality);
         }
 
-        return NodeEquality.LEXICALLY_EQUAL;
+        return resultingEquality;
     }