+ * This class is capable of comparing any task tree node which is not an iteration with an + * iteration. This is needed, because iterations may iterate exactly that node. In this + * case, the iteration would be equal to that node if it was executed exactly once. The rule + * returns lexically equal, it the child of the iteration is lexically equal to the node + * or if the child of the iteration is a selection and this selections contains a lexically equal + * node. The same applies for syntactical and semantical equality. + *
+ + * @author Patrick Harms + */ +public class NodeAndIterationComparisonRule implements NodeComparisonRule { + + /** the rule manager for internally comparing task tree nodes */ + private NodeEqualityRuleManager mRuleManager; + + /** + *+ * simple constructor to provide the rule with the node equality rule manager to be able + * to perform comparisons of the children of provided task tree nodes + *
+ * + * @param ruleManager the rule manager for comparing task tree nodes + */ + NodeAndIterationComparisonRule(NodeEqualityRuleManager ruleManager) { + super(); + mRuleManager = ruleManager; + } + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode) + */ + @Override + public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { + IIteration iteration = null; + ITaskTreeNode node = null; + + if (node1 instanceof IIteration) { + if (node2 instanceof IIteration) { + // the rule is not responsible for two iterations + return null; + } + + iteration = (IIteration) node1; + node = node2; + } + else if (node2 instanceof IIteration) { + if (node1 instanceof IIteration) { + // the rule is not responsible for two iterations + return null; + } + + iteration = (IIteration) node2; + node = node1; + } + else { + return null; + } + + // now, that we found the iteration and the node, lets compare the child of the iteration + // with the node. + if (iteration.getChildren().size() < 1) { + return null; + } + + NodeEquality nodeEquality = mRuleManager.applyRules(iteration.getChildren().get(0), node); + + // although the subtask may be identical to the node, we can not return identical, as + // the iteration is not identical to the node, but at most lexically equal + if (nodeEquality == NodeEquality.IDENTICAL) { + return NodeEquality.LEXICALLY_EQUAL; + } + else { + return nodeEquality; + } + + } +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java (revision 816) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java (revision 816) @@ -0,0 +1,99 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; + +/** + *+ * This class is capable of comparing any task tree node which is not a selection with a + * selection. This is needed, because selections may contain exactly that node. Therefore, if + * this node is selected out of a selection the selection is equal to the node itself. + * The rule returns lexically equal, it the selection contains a lexically equal node. The same + * applies for syntactical and semantical equality. + *
+ + * @author Patrick Harms + */ +public class NodeAndSelectionComparisonRule implements NodeComparisonRule { + + /** the rule manager for internally comparing task tree nodes */ + private NodeEqualityRuleManager mRuleManager; + + /** + *+ * simple constructor to provide the rule with the node equality rule manager to be able + * to perform comparisons of the children of provided task tree nodes + *
+ * + * @param ruleManager the rule manager for comparing task tree nodes + */ + NodeAndSelectionComparisonRule(NodeEqualityRuleManager ruleManager) { + super(); + mRuleManager = ruleManager; + } + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode) + */ + @Override + public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { + ISelection selection = null; + ITaskTreeNode node = null; + + if (node1 instanceof ISelection) { + if (node2 instanceof ISelection) { + // the rule is not responsible for two iterations + return null; + } + + selection = (ISelection) node1; + node = node2; + } + else if (node2 instanceof ISelection) { + if (node1 instanceof ISelection) { + // the rule is not responsible for two iterations + return null; + } + + selection = (ISelection) node2; + node = node1; + } + else { + return null; + } + + // now, that we found the iteration and the node, lets compare the child of the iteration + // with the node. + if (selection.getChildren().size() < 1) { + return null; + } + + NodeEquality mostConcreteNodeEquality = null; + + for (ITaskTreeNode child : selection.getChildren()) { + NodeEquality nodeEquality = mRuleManager.applyRules(child, node); + + if (nodeEquality != NodeEquality.UNEQUAL) { + if (mostConcreteNodeEquality == null) { + mostConcreteNodeEquality = nodeEquality; + } + else { + mostConcreteNodeEquality = + mostConcreteNodeEquality.getCommonDenominator(nodeEquality); + } + } + } + + // although the subtask may be identical to the node, we can not return identical, as + // the selection is not identical to the node, but at most lexically equal + if (mostConcreteNodeEquality == NodeEquality.IDENTICAL) { + return NodeEquality.LEXICALLY_EQUAL; + } + else { + return mostConcreteNodeEquality; + } + + } +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 815) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 816) @@ -38,4 +38,6 @@ mRuleIndex.add(new SequenceComparisonRule(this)); mRuleIndex.add(new SelectionComparisonRule(this)); + mRuleIndex.add(new NodeAndIterationComparisonRule(this)); + mRuleIndex.add(new NodeAndSelectionComparisonRule(this)); }