+ * TODO: comment + *
+ * + * @param sequences + * @return + */ + public synchronized ITaskTree createTaskTree(Collection+ * This rule identifies two task tree nodes as lexically equal, if they are both event tasks and + * if their respective event types and targets equal. + *
+ * + * @author Patrick Harms + */ +public class EventTaskComparisonRule implements NodeComparisonRule { + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode) + */ + @Override + public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { + if ((!(node1 instanceof IEventTask)) || (!(node2 instanceof IEventTask))) { + return null; + } + + if (node1 == node2) { + return NodeEquality.IDENTICAL; + } + + IEventTask task1 = (IEventTask) node1; + IEventTask task2 = (IEventTask) node2; + + if (task1.getEventType().equals(task2.getEventType()) && + task1.getEventTarget().equals(task2.getEventTarget())) + { + return NodeEquality.LEXICALLY_EQUAL; + } + else { + return NodeEquality.UNEQUAL; + } + } + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/GUIEventTaskComparisonRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/GUIEventTaskComparisonRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/GUIEventTaskComparisonRule.java (revision 893) @@ -0,0 +1,147 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.eventcore.gui.IInteraction; +import de.ugoe.cs.quest.eventcore.gui.TextInput; +import de.ugoe.cs.quest.eventcore.gui.ValueSelection; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; + +/** + *+ * This rule compares GUI event tasks (i.e. it is more concrete, than the + * {@link EventTaskComparisonRule}). Two GUI event tasks are only equal if their event type and + * target are equal. The returned equality is even more fine-grained for events whose type is + * {@link TextInput} and {@link ValueSelection}. For text inputs, lexical equality is returned if + * the same text is entered using the same key interactions. Syntactical equality is returned if + * the same text is entered using different key interactions. Semantical equality is returned if + * different text is entered, but into the same event target. Value selections are syntactically + * equal, if the same value is selected. Otherwise they are semantically equal. + *
+ * + * @author Patrick Harms + */ +public class GUIEventTaskComparisonRule implements NodeComparisonRule { + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode) + */ + @Override + public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { + if ((!(node1 instanceof IEventTask)) || (!(node2 instanceof IEventTask))) { + return null; + } + + IEventTask task1 = (IEventTask) node1; + IEventTask task2 = (IEventTask) node2; + + if ((!(task1.getEventType() instanceof IInteraction)) || + (!(task2.getEventType() instanceof IInteraction))) + { + return null; + } + + if (node1 == node2) { + return NodeEquality.IDENTICAL; + } + + if (!task1.getEventTarget().equals(task2.getEventTarget())) { + return NodeEquality.UNEQUAL; + } + + IInteraction interaction1 = (IInteraction) task1.getEventType(); + IInteraction interaction2 = (IInteraction) task2.getEventType(); + + return compareInteractions(interaction1, interaction2); + } + + /** + *+ * compares two interactions. The method delegates two + * {@link #compareTextInputs(TextInput, TextInput)} and + * {@link #compareValueSelections(ValueSelection, ValueSelection)} for text inputs and value + * selections. Otherwise it uses the equal method of the interactions for comparison. In this + * case, if the interactions equal method returns true, this method returns lexical equality. + *
+ * + * @param interaction1 the first interaction to compare + * @param interaction2 the second interaction to compare + * + * @return as described + */ + private NodeEquality compareInteractions(IInteraction interaction1, IInteraction interaction2) { + if (interaction1 == interaction2) { + return NodeEquality.LEXICALLY_EQUAL; + } + else if ((interaction1 instanceof TextInput) && (interaction2 instanceof TextInput)) { + return compareTextInputs((TextInput) interaction1, (TextInput) interaction2); + } + else if ((interaction1 instanceof ValueSelection) && + (interaction2 instanceof ValueSelection)) + { + return compareValueSelections + ((ValueSelection) interaction1, (ValueSelection) interaction2); + } + else if (interaction1.equals(interaction2)) { + return NodeEquality.LEXICALLY_EQUAL; + } + else { + return NodeEquality.UNEQUAL; + } + } + + /** + *+ * compares two text inputs. If both text inputs have the same entered text and text input + * events, they are lexically equal. If they only have the same entered text, they are + * syntactically equal. If they are only both text inputs, they are semantically equal. + * (the equality of the event targets is checked beforehand). + *
+ * + * @param interaction1 the first text input to compare + * @param interaction2 the second text input to compare + * + * @return as described + */ + private NodeEquality compareTextInputs(TextInput interaction1, TextInput interaction2) { + if (interaction1.getEnteredText().equals(interaction2.getEnteredText())) { + if (interaction1.getTextInputEvents().equals(interaction2.getTextInputEvents())) { + return NodeEquality.LEXICALLY_EQUAL; + } + else { + return NodeEquality.SYNTACTICALLY_EQUAL; + } + } + else { + return NodeEquality.SEMANTICALLY_EQUAL; + } + } + + /** + *+ * compares two value selections. If both value selections have the same selected value, they + * are syntactically equal, otherwise they are semantically equal. + * (the equality of the event targets is checked beforehand). + *
+ * + * @param interaction1 the first value selection to compare + * @param interaction2 the second value selection to compare + * + * @return as described + */ + private NodeEquality compareValueSelections(ValueSelection interaction1, + ValueSelection interaction2) + { + Object value1 = interaction1.getSelectedValue(); + Object value2 = interaction2.getSelectedValue(); + + if ((value1 == value2) || ((value1 != null) && (value1.equals(value2)))) { + return NodeEquality.SYNTACTICALLY_EQUAL; + } + else { + return NodeEquality.SEMANTICALLY_EQUAL; + } + } + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRule.java (revision 893) @@ -0,0 +1,191 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; + +/** + *
+ * This class is capable of comparing Iterations. Iterations equal at distinct levels
+ * in distinct situations. The following table shows the results of the comparison for the
+ * specific situations (the parameters are commutative). In any other situation, the comparison
+ * returns NodeEquality.UNEQUAL:
+ *
| iteration 1 | + *iteration 2 | + *comparison result | + *
|---|---|---|
| any iteration | + *any iteration with a child that is lexically equal to the child of iteration 1 | + *NodeEquality.LEXICALLY_EQUAL |
+ *
| any iteration | + *any iteration with a child that is syntactically equal to the child of iteration 1 | + *NodeEquality.SYNTACTICALLY_EQUAL |
+ *
| any iteration | + *any iteration with a child that is semantically equal to the child of iteration 1 | + *NodeEquality.SEMANTICALLY_EQUAL |
+ *
| an iteration with a selection of syntactically equal children | + *an iteration with a child that is syntactically equal to the children of the child + * selection of iteration 1 | + *NodeEquality.SYNTACTICALLY_EQUAL |
+ *
| an iteration with a selection of syntactically equal children | + *an iteration with a selection of syntactically equal children that are all syntactically + * equal to the selection of children of iteration 1 | + *NodeEquality.SYNTACTICALLY_EQUAL |
+ *
| an iteration with a selection of semantically equal children | + *an iteration with a child that is semantically equal to the children of the child + * selection of iteration 1 | + *NodeEquality.SEMANTICALLY_EQUAL |
+ *
| an iteration with a selection of semantically equal children | + *an iteration with a selection of semantically equal children that are all semantically + * equal to the selection of children of iteration 1 | + *NodeEquality.SEMANTICALLY_EQUAL |
+ *
+ * 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 + */ + IterationComparisonRule(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) { + if ((!(node1 instanceof IIteration)) || (!(node2 instanceof IIteration))) { + return null; + } + + 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.LEXICALLY_EQUAL; + } + else if ((node1.getChildren().size() == 0) || (node2.getChildren().size() == 0)) { + return NodeEquality.UNEQUAL; + } + + ITaskTreeNode child1 = node1.getChildren().get(0); + ITaskTreeNode child2 = node2.getChildren().get(0); + + // iterations may have 3 different structures. + // 1. they have one child, which is the iterated one + // 2. they have a sequence of children, which is iterated + // 3. they have a selection of different iterated variants (usually the variants are + // semantically equal) + // + // the permutations of the three variants in combination must be checked + + // check if both nodes are the same variants of iterations and if their children are equal. + // This condition matches, if both iterations are the same variants of iteration. I.e. three + // combinations of the permutation are handled herewith. + NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2); + + if (nodeEquality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)) { + // 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; + } + } + + // compare one iteration with a single node as a child and another one with a selection of + // semantically equal nodes + return selectionChildrenSemanticallyEqualNode(child1, child2); + + // all other combinations (i.e. sequence with single child and sequence with selection) + // can not match + } + + /** + *
+ * 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 NodeEquality.UNEQUAL
+ * 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.
+ *
+ * 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/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java (revision 893) @@ -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/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeComparisonRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeComparisonRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeComparisonRule.java (revision 893) @@ -0,0 +1,30 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; + +/** + *+ * A node comparison rule is used by the {@link NodeEqualityRuleManager} to compare task tree + * nodes with each other. It provides one method to be called for a comparison. + *
+ * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public interface NodeComparisonRule { + + /** + *+ * compares two nodes with each other. The result of the method is either a node equality or + * null. If it is null, it means, that the rule is not able to correctly compare the two given + * nodes + *
+ * + * @param node1 the first task tree node to compare + * @param node2 the second task tree node to compare + * + * @return as described + */ + public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2); + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEquality.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEquality.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEquality.java (revision 893) @@ -0,0 +1,113 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +/** + *+ * A node equality denotes, how equal two task tree nodes are. There are different equality levels + * which are similar to the usual design levels of GUI design. These levels are + *
+ * Nodes can be identical. This is the case if in the java virtual machine, their comparison
+ * using the == operator or the equals method return true.
+ *
+ * Nodes are lexically equal, if they represent the same events on a key stroke level to be + * carried out to execute the task. Identical nodes are also syntactically equal. + *
+ *+ * Nodes are syntactically equal, if they differ in their events on key stroke level, but the + * syntactical result is the same. For example, entering the text "hello" into a text field can + * be done by entering the letters in their correct order, but also by copying the text into the + * text field. The syntactical result is the same: The text hello was entered. But the tasks + * lexically differ because the events on key stroke level are different. On the other hand, + * lexically equal nodes are also syntactically equal. + *
+ *+ * Task tree nodes are semantically equal, if they execute the same function for editing the + * concepts. An example are a click on a button and a short cut, both executing the same function. + * These task tree nodes are syntactically and, therefore, also lexically different, but + * semantically equal. Syntactically equal task tree nodes are always also semantically equal. + *
+ * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public enum NodeEquality { + IDENTICAL, + LEXICALLY_EQUAL, + SYNTACTICALLY_EQUAL, + SEMANTICALLY_EQUAL, + UNEQUAL; + + /** + *
+ * Checks for the current node equality, if it is at least identical to the
+ * provided one or even more concrete. As an example, the node equality identical also
+ * indicates, that the nodes are e.g. lexically, syntactically and semantically equal.
+ * Therefore, the method called on IDENTICAL with SEMANTICALLY_EQUAL
+ * as parameter will return true. If this method is called on SYNTACTICALLY_EQUAL
+ * with the parameter IDENTICAL instead, it returns false;
+ *
+ * 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. + *
+ * + * @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; + } + } +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 893) @@ -0,0 +1,84 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import java.util.ArrayList; +import java.util.List; + +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; + +/** + *+ * The node equality rule manager is capable of comparing task tree nodes based on its internal list + * of comparison rules. The current list of rules contains the {@link NodeIdentityRule}, the + * {@link IterationComparisonRule}, the {@link SequenceComparisonRule}, and + * {@link SelectionComparisonRule}. These rules are asked for comparing the two provided task tree + * nodes in the mentioned order. If a rule returns a node equality other than null, this equality is + * returned. Otherwise the next rule is asked. + *
+ * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class NodeEqualityRuleManager { + + /** */ + private List+ * initializes the node equality rule manager by filling the internal list of comparison rules. + * This method must be called before any other method is called on the rule manager. + *
+ */ + public void init() { + mRuleIndex = new ArrayList
+ * this method performs a comparison of the two provided task tree nodes. It iterates its
+ * internal comparison rules. If the first rule returns a node equality other than null,
+ * this equality is returned. Otherwise the next rule is tried. If no rule returns an equality
+ * NodeEquality.UNEQUAL is returned.
+ *
+ * This comparison rule returns NodeEquality.IDENTICAL if the comparison of the two
+ * task tree nodes using the == operator or the equals method return true.
+ * Else it returns null to denote, that it can not compare the nodes.
+ *
+ * this node comparison rule is capable of comparing selections. If both selections do not have + * 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. + *
+ * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class SelectionComparisonRule 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 + */ + SelectionComparisonRule(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) { + if ((!(node1 instanceof ISelection)) || (!(node2 instanceof ISelection))) { + return null; + } + + 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; + } + + NodeEquality selectionEquality = NodeEquality.LEXICALLY_EQUAL; + + // 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 (childEquality != null) { + selectionEquality = selectionEquality.getCommonDenominator(childEquality); + } + else { + return NodeEquality.UNEQUAL; + } + } + + // 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; + } + } + + return selectionEquality; + } + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRule.java (revision 893) @@ -0,0 +1,76 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; + +/** + *+ * This rule is capable of comparing sequences. If both sequences do not have children, they are + * treated as lexically equal. Sequences are lexically equal, if they have the same number and + * order of lexically equal children. The rule can not decide, if two sequences are syntactically + * or semantically equal. + *
+ * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class SequenceComparisonRule 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 + */ + SequenceComparisonRule(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) { + if ((!(node1 instanceof ISequence)) || (!(node2 instanceof ISequence))) { + return null; + } + + 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)) { + return NodeEquality.LEXICALLY_EQUAL; + } + + if (node1.getChildren().size() != node2.getChildren().size()) { + return NodeEquality.UNEQUAL; + } + + NodeEquality resultingEquality = NodeEquality.LEXICALLY_EQUAL; + for (int i = 0; i < node1.getChildren().size(); i++) { + ITaskTreeNode child1 = node1.getChildren().get(i); + ITaskTreeNode child2 = node2.getChildren().get(i); + + NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2); + + if ((nodeEquality == null) || (nodeEquality == NodeEquality.UNEQUAL)) { + return NodeEquality.UNEQUAL; + } + + resultingEquality = resultingEquality.getCommonDenominator(nodeEquality); + } + + return resultingEquality; + } + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultEventTargetSequenceDetectionRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultEventTargetSequenceDetectionRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultEventTargetSequenceDetectionRule.java (revision 893) @@ -0,0 +1,153 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class DefaultEventTargetSequenceDetectionRule implements TemporalRelationshipRule { + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * TaskTreeBuilder, TaskTreeNodeFactory) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof ISequence)) { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + IEventTarget currentEventTarget = null; + int startingIndex = -1; + + int index = 0; + while (index < parent.getChildren().size()) { + ITaskTreeNode child = parent.getChildren().get(index); + + IEventTarget eventTarget = determineEventTarget(child); + + if (((eventTarget == null) && (currentEventTarget != null)) || + ((eventTarget != null) && (!eventTarget.equals(currentEventTarget)))) + { + if (startingIndex < 0) { + startingIndex = index; + currentEventTarget = eventTarget; + } + else { + int endIndex = index - 1; + + // only reduce to a sequence, if it is not a sequence with only one child + // or if this child is not a sequence itself + if ((startingIndex != endIndex) || + (!(parent.getChildren().get(startingIndex) instanceof ISequence))) + { + handleEventTargetSequence + (parent, startingIndex, endIndex, builder, nodeFactory, result); + + result.setRuleApplicationStatus + (RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + else { + // here a new sequence on a new target begins + startingIndex = index; + currentEventTarget = eventTarget; + } + } + } + + index++; + } + + if (startingIndex > -1) { + int endIndex = parent.getChildren().size() - 1; + + if (finalize) { + // only reduce to a sequence, if it is not a sequence with only one child + // or if this child is not a sequence itself + if ((startingIndex > 0) && + ((startingIndex != endIndex) || + (!(parent.getChildren().get(startingIndex) instanceof ISequence)))) + { + handleEventTargetSequence + (parent, startingIndex, endIndex, builder, nodeFactory, result); + + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + } + } + else { + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + } + + return result; + } + + /** + * TODO: comment + * + * @param child + * @return + */ + private IEventTarget determineEventTarget(ITaskTreeNode node) { + if (node instanceof IEventTask) { + return ((IEventTask) node).getEventTarget(); + } + else { + IEventTarget commonTarget = null; + + for (ITaskTreeNode child : node.getChildren()) { + if (commonTarget == null) { + commonTarget = determineEventTarget(child); + } + else { + if (!commonTarget.equals(determineEventTarget(child))) { + return null; + } + } + } + + return commonTarget; + } + } + + /** + * TODO: comment + * + */ + private void handleEventTargetSequence(ITaskTreeNode parent, + int startIndex, + int endIndex, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + ISequence sequence = nodeFactory.createNewSequence(); + + for (int i = startIndex; i <= endIndex; i++) { + builder.addChild(sequence, parent.getChildren().get(startIndex)); + builder.removeChild((ISequence) parent, startIndex); + } + + builder.addChild((ISequence) parent, startIndex, sequence); + + result.addNewlyCreatedParentNode(sequence); + } + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java (revision 893) @@ -0,0 +1,345 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; + +import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class DefaultGuiElementSequenceDetectionRule implements TemporalRelationshipRule { + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * TaskTreeBuilder, TaskTreeNodeFactory) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof ISequence)) { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + IGUIElement lastGuiElement = null; + int index = 0; + while (index < parent.getChildren().size()) { + ITaskTreeNode child = parent.getChildren().get(index); + IGUIElement currentGuiElement = getGUIElement(child); + if ((index > 0) && (!lastGuiElement.equals(currentGuiElement))) { + ReducableCommonDenominator commonDenominator = + getNextReducableCommonDenominator(parent, index - 1); + + if (commonDenominator != null) { + // condense only if not all children would be condensed or if we can be sure, + // that there will be no further child that should be included in the condensed + // sequence + if ((commonDenominator.noOfTasks < parent.getChildren().size()) && + (!isOnGuiElementPath(commonDenominator.commonGuiElement, currentGuiElement))) + { + condenseTasksToSequence(parent, index, commonDenominator.noOfTasks, + builder, nodeFactory, result); + + result.setRuleApplicationStatus + (RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + else { + // the common denominator is on the parent path of the next GUI element. + // Therefore, the current sequences is not finished yet. So break up. + result.setRuleApplicationStatus + (RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + } + } + + lastGuiElement = currentGuiElement; + index++; + } + + ReducableCommonDenominator commonDenominator = + getNextReducableCommonDenominator(parent, parent.getChildren().size() - 1); + + if ((commonDenominator != null) && + (commonDenominator.noOfTasks < parent.getChildren().size())) + { + if (finalize) { + condenseTasksToSequence + (parent, index, commonDenominator.noOfTasks, builder, nodeFactory, result); + + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + + return result; + } + else { + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + } + + return result; + } + + /** + *+ * TODO: comment + *
+ * + * @param guiElement + * @param detectedTasks + * @param parent + * @param index + * @param builder + * @param nodeFactory + * @return + */ + private void condenseTasksToSequence(ITaskTreeNode parent, + int parentIndex, + int noOfTasks, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + ISequence newSequence = nodeFactory.createNewSequence(); + for (int i = 0; i < noOfTasks; i++) { + builder.addChild(newSequence, parent.getChildren().get(parentIndex - noOfTasks)); + // remove exactly the same number of children from the parent. + builder.removeChild((ISequence) parent, parentIndex - noOfTasks); + } + + builder.addChild((ISequence) parent, parentIndex - noOfTasks, newSequence); + result.addNewlyCreatedParentNode(newSequence); + } + + /** + *+ * TODO: comment + *
+ * + * @param detectedTasks + * @return + */ + private ReducableCommonDenominator getNextReducableCommonDenominator(ITaskTreeNode parent, + int childIndex) + { + ReducableCommonDenominator commonDenominator = null; + + // a common denominator can only exist for at least two task tree nodes + if (childIndex > 0) { + // start with the last one + int pos = childIndex; + + commonDenominator = new ReducableCommonDenominator(); + + // check for further predecessors, if they match the same common denominator + IGUIElement currentCommonDenominator = null; + do { + if (--pos < 0) { + currentCommonDenominator = null; + } + else { + currentCommonDenominator = getCommonDenominator + (getGUIElement(parent.getChildren().get(pos)), + getGUIElement(parent.getChildren().get(pos + 1))); + } + + if (commonDenominator.commonGuiElement == null) { + commonDenominator.commonGuiElement = currentCommonDenominator; + } + } + while ((commonDenominator.commonGuiElement != null) && + (commonDenominator.commonGuiElement.equals(currentCommonDenominator))); + + if (commonDenominator.commonGuiElement != null) { + // pos points to the last element, that has not the same common denominator. + // This one must be subtracted from the task number as well + commonDenominator.noOfTasks = childIndex - pos; + } + else { + commonDenominator = null; + } + } + + return commonDenominator; + } + + /** + *+ * TODO: comment + *
+ * + * @param child + * @return + */ + private IGUIElement getGUIElement(ITaskTreeNode node) { + List+ * TODO: comment + *
+ * + * @param detectedTaskGroups + * @return + */ + /*private IGUIElement getCommonDenominator(Stack+ * TODO: comment + *
+ * + * @param child + * @return + */ + private IGUIElement getCommonDenominator(IGUIElement guiElement1, IGUIElement guiElement2) { + List+ * TODO: comment + *
+ * + * @param child + * @return + */ + private IGUIElement getCommonDenominator(List+ * TODO: comment + *
+ * + * @param child + * @return + */ + private void getTerminalGUIElements(ITaskTreeNode node, List+ * TODO: comment + *
+ * + * @param currentCommonDenominator + * @param guiElement + * @return + */ + private boolean isOnGuiElementPath(IGUIElement potentialPathElement, IGUIElement child) { + IGUIElement guiElement = child; + + while (guiElement != null) { + if (guiElement.equals(potentialPathElement)) { + return true; + } + guiElement = guiElement.getParent(); + } + + return false; + } + + /** + * + */ + private static class ReducableCommonDenominator { + + /** the GUI element being the common denominator */ + private IGUIElement commonGuiElement; + + /** the number of tasks that match the common denominator */ + private int noOfTasks; + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return noOfTasks + " tasks on " + commonGuiElement; + } + + } +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java (revision 893) @@ -0,0 +1,118 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.eventcore.gui.IInteraction; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class DefaultGuiEventSequenceDetectionRule implements TemporalRelationshipRule { + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * TaskTreeBuilder, TaskTreeNodeFactory) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof ISequence)) { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + int sequenceStartingIndex = -1; + + int index = 0; + while (index < parent.getChildren().size()) { + ITaskTreeNode child = parent.getChildren().get(index); + + if ((child instanceof IEventTask) && + (((IEventTask) child).getEventType() instanceof IInteraction)) + { + IInteraction eventType = (IInteraction) ((IEventTask) child).getEventType(); + + if (eventType.finishesLogicalSequence() && (sequenceStartingIndex > -1)) + { + // There are several situations in which this implementation may cause infinite + // loops. This is because the rule manager will reapply rules until + // no rule is applied anymore. A sequence identified in a first iteration will + // be identified as a sequence also in a second iteration. As an example + // many sequences start with an interaction starting that sequence and end + // with an interaction ending that sequence. This will be reidentified as + // further subsequence. It must therefore be assured, that a sequence, that + // was once identified is not reidentified in a further application of the rule. + // For this, the implementation performs a kind of dry run. It creates a list of + // children that would belong to an identified sequence. Only if this list is + // not a reidentification then a new sequence is created and added to the + // parent. If it is a reidentification can be identified, if the list of + // children will contain all children of the parent, or if the list of children + // only consists of one sequence. Further, an identified sequence must at least + // have one child. + if (((sequenceStartingIndex != 0) || + (index != (parent.getChildren().size() - 1))) && + (((index - sequenceStartingIndex) > 0) || + (((index - sequenceStartingIndex) == 0) && + (!eventType.startsLogicalSequence())))) + { + boolean allNewChildrenAreSequences = true; + + for (int j = sequenceStartingIndex; + ((allNewChildrenAreSequences) && (j < index)); j++) + { + allNewChildrenAreSequences &= + (parent.getChildren().get(j) instanceof ISequence); + } + + if (!allNewChildrenAreSequences) { + ISequence sequence = nodeFactory.createNewSequence(); + + for (int j = sequenceStartingIndex; j < index; j++) { + builder.addChild + (sequence, parent.getChildren().get(sequenceStartingIndex)); + builder.removeChild((ISequence) parent, sequenceStartingIndex); + } + + if (!eventType.startsLogicalSequence()) { + builder.addChild + (sequence, parent.getChildren().get(sequenceStartingIndex)); + builder.removeChild((ISequence) parent, sequenceStartingIndex); + } + + builder.addChild((ISequence) parent, sequenceStartingIndex, sequence); + + result.addNewlyCreatedParentNode(sequence); + result.setRuleApplicationStatus + (RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + } + } + + if (eventType.startsLogicalSequence()) { + sequenceStartingIndex = index; + } + } + + index++; + } + + if (sequenceStartingIndex >= 0) { + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + + return result; + } + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java (revision 893) @@ -0,0 +1,727 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEquality; +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; + +/** + *+ * iterations in a list of nodes are equal subsequences following each other directly. The + * subsequences can be of any length depending on the type of equality they need to have. If the + * subsequences have to be lexically equal, then they have to have the same length if they only + * contain event tasks. As an example entering text can be done through appropriate keystrokes or + * through pasting the text. As a result, two syntactically different sequences are semantically + * equal. If both follow each other, then they are an iteration of semantically equal children. + * But they are not lexically equal. + *
+ *+ * This class determines equal subsequences following each other. It is provided with a minimal node + * equality the equal nodes should have. Through this, it is possible to find e.g. lexically + * equal subsequence through a first application of this rule and semantically equal children to + * a later application of this rule. This is used by the {@link TemporalRelationshipRuleManager} + * which instantiates this rule three times, each with a different minimal equality. + *
+ *+ * The equal subsequences are determined through trial and error. This algorithm has a high effort + * as it tries in the worst case all possible combinations of sub lists in all possible parts of + * the list of children of a provided parent node. The steps for each trial are. + *
+ * the node equality manager needed for comparing task tree nodes with each other + *
+ */ + private NodeEqualityRuleManager nodeEqualityRuleManager; + + /** + *+ * the minimal node equality two identified sublists need to have to consider them as equal + * and to create an iteration for + *
+ */ + private NodeEquality minimalNodeEquality; + + /** + *+ * instantiates the rule and initializes it with a node equality rule manager and the minimal + * node equality identified sublist must have to consider them as iterated. + *
+ */ + DefaultIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager, + NodeEquality minimalNodeEquality) + { + super(); + this.nodeEqualityRuleManager = nodeEqualityRuleManager; + this.minimalNodeEquality = minimalNodeEquality; + } + + /* + * (non-Javadoc) + * + * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof ISequence)) { + return null; + } + + if (!finalize) { + // the rule is always feasible as iterations may occur at any time + RuleApplicationResult result = new RuleApplicationResult(); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + return result; + } + + // parent must already have at least 2 children + if ((parent.getChildren() == null) || (parent.getChildren().size() < 2)) { + return null; + } + + + // to find longer iterations first, start with long sequences + SubSequences subSequences = getEqualSubsequences(parent, treeBuilder, nodeFactory); + + if (subSequences != null) { + RuleApplicationResult result = new RuleApplicationResult(); + + mergeEqualNodes(subSequences.equalVariants, treeBuilder, nodeFactory); + IIteration newIteration = createIterationBasedOnIdentifiedVariants + (subSequences, treeBuilder, nodeFactory, result); + + determineNewlyCreatedParentTasks(parent, newIteration, result); + + // remove iterated children + for (int j = subSequences.start; j < subSequences.end; j++) { + treeBuilder.removeChild((ISequence) parent, subSequences.start); + } + + // add the new iteration instead + treeBuilder.addChild((ISequence) parent, subSequences.start, newIteration); + + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + + return null; + } + + /** + *+ * this method initiates the trial and error algorithm denoted in the description of this class. + * Its main purpose is the selection of a subpart of all children in the parent node in which + * equal sublists shall be searched. It is important, to always find the last iterations in a + * part first. The reason for this are iterations of iterations. If we always found the first + * iteration in a subpart first, then this may be an iteration of iterations. However, there + * may be subsequent iterations to be included in this iteration. But these iterations are not + * found yet, as they occur later in the sequence. Therefore, if we always find the last + * iteration in a sequence first, iterations of iterations are identified, last. + *
+ * + * @param parent the parent node in which iterations of children shall be found + * @param treeBuilder the tree builder that can be used for connecting task tree nodes + * @param nodeFactory the node factory that can be used for instantiating task tree nodes + * + * @return the iterated subsequences identified in a specific part (contains the equal + * subsequences as well as the start (inclusive) and end (exclusive) index of the + * subpart in which the sequences were found) + */ + private SubSequences getEqualSubsequences(ITaskTreeNode parent, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory) + { + SubSequences subSequences = null; + + FIND_ITERATION: + for (int end = parent.getChildren().size(); end > 0; end--) { + for (int start = 0; start < end; start++) { + boolean useEqualSublistLengths = equalSublistLengthsCanBeUsed(parent, start, end); + + subSequences = new SubSequences(); + subSequences.start = start; + + boolean foundFurtherVariants = findFurtherVariants + (subSequences, parent, start, end, treeBuilder, nodeFactory, + useEqualSublistLengths); + + if (foundFurtherVariants) { + break FIND_ITERATION; + } + else { + subSequences = null; + } + } + } + + return subSequences; + } + + /** + *+ * for optimization purposes, we check if the length of the sublists to be identified as + * iterations has to be the same for any sublist. This only applies, if the minimum node + * equality to be checked for is lexical equality. If the children of the parent are all event + * tasks, then sublists can only be lexically equal, if they all have the same length. + * Therefore we check, if the minimal node equality is lexical equality. And if so, we also + * check if all children of the parent in which an iteration shall be searched for are event + * tasks. + *
+ * + * @param parent the parent node to search for iterations of its children + * @param start the beginning of the subpart (inclusive) to be considered + * @param end the end of the subpart (exclusive) to be considered + * + * @return true, if the sublists must have the same lengths, false else + */ + private boolean equalSublistLengthsCanBeUsed(ITaskTreeNode parent, int start, int end) { + boolean equalLengthsCanBeUsed = minimalNodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL); + + if (equalLengthsCanBeUsed) { + for (int i = start; i < end; i++) { + if (!(parent.getChildren().get(i) instanceof IEventTask)) { + equalLengthsCanBeUsed = false; + break; + } + } + } + + return equalLengthsCanBeUsed; + } + + /** + *+ * this method starts at a specific position in the list of children of the provided parent + * and checks, if it finds a further sublist, that matches the already found sublists. If + * the sublist lengths must be equal, it only searches for a sublist of the same length of the + * already found sublists. The method calls itself if it identifies a further equal sublist but + * if the end of the subpart of children is not yet reached. + *
+ * + * @param subSequences the sublist found so far against which equality of the next + * sublist must be checked + * @param parent the parent node of which the children are analyzed + * @param start the starting index from which to start the next sublist to be + * identified + * @param end the end index (exclusive) of the current subpart of children + * in which iterations are searched for + * @param treeBuilder the tree builder that can be used for connecting task tree + * nodes + * @param nodeFactory the node factory that can be used for instantiating task tree + * nodes + * @param useEqualSublistLengths true if the sublists to be searched for all need to have the + * same length + * + * @return true if a further equal variant was found, false else + */ + private boolean findFurtherVariants(SubSequences subSequences, + ITaskTreeNode parent, + int start, + int end, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory, + boolean useEqualSublistLengths) + { + boolean foundFurtherVariants = (start == end) && (subSequences.equalVariants.size() > 1); + + int minChildCount = 1; + int maxChildCount = end - start; + + if (useEqualSublistLengths && (subSequences.equalVariants.size() > 0)) { + minChildCount = subSequences.equalVariants.get(0).getChildren().size(); + maxChildCount = Math.min(minChildCount, maxChildCount); + } + + for (int childCount = minChildCount; childCount <= maxChildCount; childCount++) { + if (useEqualSublistLengths && (((end - start) % childCount) != 0)) { + continue; + } + + ISequence furtherVariant = nodeFactory.createNewSequence(); + + for (int j = start; j < start + childCount; j++) { + treeBuilder.addChild(furtherVariant, parent.getChildren().get(j)); + } + + boolean allVariantsEqual = true; + + for (ITaskTreeNode equalVariant : subSequences.equalVariants) { + NodeEquality nodeEquality = + nodeEqualityRuleManager.applyRules(equalVariant, furtherVariant); + + if (!nodeEquality.isAtLeast(minimalNodeEquality)) { + allVariantsEqual = false; + break; + } + } + + if (allVariantsEqual) { + + // we found a further variant. Add it to the list of variants and try to find + // further variants. Ignore, if none is available + int index = subSequences.equalVariants.size(); + subSequences.equalVariants.add(index, furtherVariant); + + foundFurtherVariants = findFurtherVariants + (subSequences, parent, start + childCount, end, treeBuilder, nodeFactory, + useEqualSublistLengths); + + if (foundFurtherVariants) { + subSequences.end = end; + break; + } + else { + subSequences.equalVariants.remove(index); + } + } + } + + return foundFurtherVariants; + } + + /** + *+ * this method merges task tree nodes in a list, if they can be merged. for this, it tries + * to merge every node with every other node in the provided list using the + * {@link #mergeEqualTasks(ITaskTreeNode, ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory)} + * method. If a merge is possible, it removes the merged nodes from the list and adds the + * merge result. + *
+ * + * @param nodes the list of nodes to be merged + * @param treeBuilder the tree builder that can be used for connecting task tree nodes + * @param nodeFactory the node factory that can be used for instantiating task tree nodes + */ + private void mergeEqualNodes(List+ * this method merges two equal tasks with each other if possible. If the tasks are lexically + * equal, the first of them is returned as merge result. If both tasks are of the same + * temporal relationship type, the appropriate merge method is called to merge them. If one + * of the nodes is a selection, the other one is added as a variant of this selection. + * (However, if both nodes are selections, they are merged using the appropriate merge method.) + * If merging is not possible, then a selection of both provided nodes is created and + * returned as merge result. + *
+ * + * @param node1 the first task to be merged + * @param node2 the second task to be merged + * @param treeBuilder the tree builder that can be used for connecting task tree nodes + * @param nodeFactory the node factory that can be used for instantiating task tree nodes + * + * @return the result of the merge + */ + private ITaskTreeNode mergeEqualTasks(ITaskTreeNode node1, + ITaskTreeNode node2, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory) + { + ITaskTreeNode mergeResult = null; + + if ((node1 instanceof ISequence) && (node2 instanceof ISequence)) { + mergeResult = mergeEqualSequences + ((ISequence) node1, (ISequence) node2, treeBuilder, nodeFactory); + } + else if ((node1 instanceof ISelection) && (node2 instanceof ISelection)) { + mergeResult = mergeEqualSelections + ((ISelection) node1, (ISelection) node2, treeBuilder, nodeFactory); + } + else if ((node1 instanceof IIteration) && (node2 instanceof IIteration)) { + mergeResult = mergeEqualIterations + ((IIteration) node1, (IIteration) node2, treeBuilder, nodeFactory); + } + else if (node1 instanceof ISelection) { + treeBuilder.addChild((ISelection) node1, node2); + mergeResult = node1; + } + else if (node2 instanceof ISelection) { + treeBuilder.addChild((ISelection) node2, node1); + mergeResult = node2; + } + else if (node1 instanceof IIteration) { + mergeResult = mergeEqualTasks + (((IIteration) node1).getChildren().get(0), node2, treeBuilder, nodeFactory); + + if (mergeResult != null) { + IIteration iteration = nodeFactory.createNewIteration(); + treeBuilder.setChild(iteration, mergeResult); + mergeResult = iteration; + } + } + else if (node2 instanceof IIteration) { + mergeResult = mergeEqualTasks + (((IIteration) node2).getChildren().get(0), node1, treeBuilder, nodeFactory); + + if (mergeResult != null) { + IIteration iteration = nodeFactory.createNewIteration(); + treeBuilder.setChild(iteration, mergeResult); + mergeResult = iteration; + } + } + else { + NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules(node1, node2); + + if (nodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)) { + mergeResult = node1; + } + } + + if (mergeResult == null) { + mergeResult = nodeFactory.createNewSelection(); + treeBuilder.addChild((ISelection) mergeResult, node1); + treeBuilder.addChild((ISelection) mergeResult, node2); + } + + return mergeResult; + } + + /** + *+ * merges equal sequences. This is done through trying to merge each node of sequence 1 with + * the node in sequence 2 being located at the same position. If not all children can be merged + * or if the sequences have different lengths, null is returned to indicate, that merging is + * not possible. For merging children, the + * {@link #mergeEqualTasks(ITaskTreeNode, ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory)} + * method is called. + *
+ * + * @param sequence1 the first sequence to be merged + * @param sequence2 the second sequence to be merged + * @param treeBuilder the tree builder that can be used for connecting task tree nodes + * @param nodeFactory the node factory that can be used for instantiating task tree nodes + * + * @return the result of the merge or null if merging was not possible + */ + private ISequence mergeEqualSequences(ISequence sequence1, + ISequence sequence2, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory) + { + ISequence mergeResult = null; + + if (sequence1.getChildren().size() == sequence2.getChildren().size()) { + mergeResult = nodeFactory.createNewSequence(); + + for (int i = 0; i < sequence1.getChildren().size(); i++) { + ITaskTreeNode mergedNode = mergeEqualTasks + (sequence1.getChildren().get(i), sequence2.getChildren().get(i), + treeBuilder, nodeFactory); + + if (mergedNode != null) { + treeBuilder.addChild(mergeResult, mergedNode); + } + else { + mergeResult = null; + break; + } + } + } + + return mergeResult; + } + + /** + *+ * merges equal selections. This is done through trying to merge each node of selections with + * each other. For this, the method + * {@link #mergeEqualNodes(List, ITaskTreeBuilder, ITaskTreeNodeFactory)} is called with a + * join of the child list of both selections. + *
+ * + * @param selection1 the first selection to be merged + * @param selection2 the second selection to be merged + * @param treeBuilder the tree builder that can be used for connecting task tree nodes + * @param nodeFactory the node factory that can be used for instantiating task tree nodes + * + * @return the result of the merge which is not null + */ + private ITaskTreeNode mergeEqualSelections(ISelection selection1, + ISelection selection2, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory) + { + ISelection mergeResult = nodeFactory.createNewSelection(); + + for (int i = 0; i < selection1.getChildren().size(); i++) { + treeBuilder.addChild(mergeResult, selection1.getChildren().get(i)); + } + + for (int i = 0; i < selection2.getChildren().size(); i++) { + treeBuilder.addChild(mergeResult, selection2.getChildren().get(i)); + } + + mergeEqualNodes(mergeResult.getChildren(), treeBuilder, nodeFactory); + + return mergeResult; + } + + /** + *+ * merges equal iterations. This is done through merging the children of both iterations. If + * this is possible, a resulting iteration with the merge result of the children as its own + * child is returned. Otherwise null is returned to indicate that merging was not possible. + *
+ * + * @param selection1 the first iteration to be merged + * @param selection2 the second iteration to be merged + * @param treeBuilder the tree builder that can be used for connecting task tree nodes + * @param nodeFactory the node factory that can be used for instantiating task tree nodes + * + * @return the result of the merge or null if merging is not possible + */ + private ITaskTreeNode mergeEqualIterations(IIteration iteration1, + IIteration iteration2, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory) + { + ITaskTreeNode mergedChild = mergeEqualTasks + (iteration1.getChildren().get(0), iteration2.getChildren().get(0), + treeBuilder, nodeFactory); + + IIteration mergeResult = null; + + if (mergedChild != null) { + mergeResult = nodeFactory.createNewIteration(); + treeBuilder.setChild(mergeResult, mergedChild); + } + + return mergeResult; + } + + /** + *+ * this is a convenience method to create an iteration based on the identified and already + * merged iterated subsequences. This method creates the simplest iteration possible. As an + * example, if always the same task tree node is iterated, it becomes the child of the + * iteration. If a sequence of tasks is iterated, this sequence becomes the child of the + * iteration. It several equal sublists or nodes which are not lexically equal are iterated + * they become a selection which in turn become the child of the iteration. + *
+ * + * @param subsequences the identified and already merged equal subsequences + * @param treeBuilder the tree builder that can be used for connecting task tree nodes + * @param nodeFactory the node factory that can be used for instantiating the iteration + * + * @return the resulting iteration + */ + private IIteration createIterationBasedOnIdentifiedVariants(SubSequences subsequences, + ITaskTreeBuilder treeBuilder, + ITaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + IIteration newIteration = nodeFactory.createNewIteration(); + result.addNewlyCreatedParentNode(newIteration); + + if (subsequences.equalVariants.size() == 1) { + // all children are the same. Create an iteration of this child + if (subsequences.equalVariants.get(0).getChildren().size() == 1) { + // there is only one equal variant and this has only one child. So create an + // iteration of this child + treeBuilder.setChild + (newIteration, subsequences.equalVariants.get(0).getChildren().get(0)); + } + else { + // there was an iteration of one equal sequence + treeBuilder.setChild(newIteration, subsequences.equalVariants.get(0)); + result.addNewlyCreatedParentNode(subsequences.equalVariants.get(0)); + } + } + else { + // there are distinct variants of equal subsequences or children --> create an + // iterated selection + ISelection selection = nodeFactory.createNewSelection(); + result.addNewlyCreatedParentNode(selection); + + for (ITaskTreeNode variant : subsequences.equalVariants) { + if (variant.getChildren().size() == 1) { + treeBuilder.addChild(selection, variant.getChildren().get(0)); + } + else { + treeBuilder.addChild(selection, variant); + result.addNewlyCreatedParentNode(variant); + } + } + + treeBuilder.setChild(newIteration, selection); + } + + return newIteration; + } + + /** + *+ * as the method has to denote all newly created parent nodes this method identifies them by + * comparing the existing subtree with the newly created iteration. Only those parent nodes + * in the new iteration, which are not already found in the existing sub tree are denoted as + * newly created. We do this in this way, as during the iteration detection algorithm, many + * parent nodes are created, which may be discarded later. It is easier to identify the + * remaining newly created parent nodes through this way than to integrate it into the + * algorithm. + *
+ * + * @param existingSubTree the existing subtree + * @param newSubTree the identified iteration + * @param result the rule application result into which the newly created parent nodes + * shall be stored. + */ + private void determineNewlyCreatedParentTasks(ITaskTreeNode existingSubTree, + ITaskTreeNode newSubTree, + RuleApplicationResult result) + { + List+ * convenience method to determine all parent nodes existing in a subtree + *
+ * + * @param subtree the subtree to search for parent nodes in + * + * @return a list of parent nodes existing in the subtree + */ + private List+ * used to have a container for equal sublists identified in a sub part of the children of + * a parent node. + *
+ * + * @author Patrick Harms + */ + private static class SubSequences { + + /** + *+ * the beginning of the subpart of the children of the parent node in which the sublists + * are found (inclusive) + *
+ */ + public int start; + + /** + *+ * the end of the subpart of the children of the parent node in which the sublists + * are found (exclusive) + *
+ */ + public int end; + + /** + *+ * the equal sublists found in the subpart of the children of the parent node + *
+ */ + List+ * The rule application result describes the result of applying a {@link TemporalRelationshipRule} + * on a task tree node. It contains a {@link RuleApplicationStatus} and a list of all parent + * task tree nodes that were created during a rule application. See the description of + * {@link TemporalRelationshipRule} for more details. + *
+ * + * @author Patrick Harms + */ +class RuleApplicationResult { + + /** */ + private RuleApplicationStatus status = RuleApplicationStatus.RULE_NOT_APPLIED; + + /** */ + private List+ * create a rule application result with a status {@link RuleApplicationStatus#RULE_NOT_APPLIED} + *
+ */ + RuleApplicationResult() { + // this is the default indicating nothing so far + } + + /** + *+ * set the rule application status + *
+ */ + void setRuleApplicationStatus(RuleApplicationStatus status) { + this.status = status; + } + + /** + *+ * return the rule application status + *
+ */ + RuleApplicationStatus getRuleApplicationStatus() { + return status; + } + + /** + *+ * add a further parent node created during the rule application + *
+ */ + void addNewlyCreatedParentNode(ITaskTreeNode newParent) { + newParents.add(newParent); + } + + /** + *+ * return all parent nodes created during the rule application + *
+ */ + List+ * The rule application status describes the result of applying a {@link TemporalRelationshipRule} + * on a task tree node. See the description of {@link TemporalRelationshipRule} for more details. + *
+ * + * @author Patrick Harms + */ +enum RuleApplicationStatus { + RULE_APPLICATION_FINISHED, + RULE_APPLICATION_FEASIBLE, + RULE_NOT_APPLIED; +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRule.java (revision 893) @@ -0,0 +1,55 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; + +/** + *+ * a temporal relation ship is able to detected temporal relationships between the child nodes + * of the parent node provided to the + * {@link #apply(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)} method. A rule + * created temporal relationships between the child nodes, i.e. substructures in the task tree, if + * it detects a temporal relationship and it can be sure that it is complete. Incomplete but + * detected temporal relationships may occur, if there can be more children expected to be added + * to the provided parent node. This could be the case during parsing a interaction log file of + * a GUI. + *
+ * + * @author Patrick Harms + */ +interface TemporalRelationshipRule { + + /** + *+ * applies the rule to the given parent node. The provided builder and node factory are used + * to create substructures in the task tree for the identified temporal relationships. The + * finalize parameter is used to command the rule to finish rule applications, in the case it + * is known that no further data will be available. + *
+ *+ * The returned rule application result is null, if the rule can not be applied, i.e. it does not + * detect a temporal relationship. It returns a rule application result with a status + * {@link RuleApplicationStatus#RULE_APPLICATION_FINISHED} if the rule was applied. The result + * contains all newly created parent nodes. It returns a rule application result with status + * {@link RuleApplicationStatus#RULE_APPLICATION_FEASIBLE} if the rule would be applicable if + * further children would be available in the parent node. This status MUST not be returned if + * the finalize parameter is true. In this case the rule must be applied or not. + *
+ * + * @param parent the parent node with the children to apply the rule on + * @param builder the builder to be used for creating substructures for the identified + * temporal relationships + * @param nodeFactory the node factory to be used for creating substructures for the identified + * temporal relationships + * @param finalize true, if the rule shall not expect further children to come and that it + * should therefore be applied in any case + * + * @return the rule application result as described. + */ + RuleApplicationResult apply(ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize); + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java (revision 893) @@ -0,0 +1,221 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEquality; +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.util.console.Console; + +/** + *+ * This class is responsible for applying temporal relationship rules on a task tree. Through this, + * a flat task tree is restructured to have more depth but to include more temporal relationships + * between task tree nodes which are not only a major sequence. I.e. through the application of + * rule iterations and selections of task tree nodes are detected. Which kind of temporal relations + * between task tree nodes are detected depends on the {@link TemporalRelationshipRule}s known to + * this class. + *
+ *The class holds references to the appropriate {@link TemporalRelationshipRule}s and calls + * their {@link TemporalRelationshipRule#apply(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)} + * method for each node in the task tree it is needed for. The general behavior of this class is + * the following: + *
+ * the node equality manager needed by the rules to compare task tree nodes with each other + *
+ */ + private NodeEqualityRuleManager nodeEqualityRuleManager; + + /** + *+ * the temporal relationship rule known to the manager. The rules are applied in the order + * they occur in this list. + *
+ */ + private List+ * initialize the manager with a node equality rule manager to be used by the known rules + * for task tree node comparison. + *
+ */ + public TemporalRelationshipRuleManager(NodeEqualityRuleManager nodeEqualityRuleManager) { + super(); + this.nodeEqualityRuleManager = nodeEqualityRuleManager; + } + + /** + *+ * initialized the temporal relationship rule manager by instantiating the known rules and + * providing them with a reference to the node equality manager or other information they need. + *
+ */ + public void init() { + rules.add(new DefaultGuiElementSequenceDetectionRule()); + rules.add(new DefaultEventTargetSequenceDetectionRule()); + rules.add(new TrackBarSelectionDetectionRule(nodeEqualityRuleManager)); + rules.add(new DefaultGuiEventSequenceDetectionRule()); + + rules.add(new DefaultIterationDetectionRule + (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL)); + rules.add(new DefaultIterationDetectionRule + (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL)); + rules.add(new DefaultIterationDetectionRule + (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL)); + } + + /** + *+ * applies the known rules to the provided parent node. For the creation of further nodes, + * the provided builder and node factory are utilized. If the finalize parameter is true, the + * rule application is finalized as far as possible without waiting for further data. If it is + * false, the rule application is broken up at the first rule returning, that its application + * would be feasible. + *
+ * + * @param parent the parent node to apply the rules on + * @param builder the task tree builder to be used for linking task tree nodes with each + * other + * @param nodeFactory the node factory to be used for instantiating new task tree nodes. + * @param finalize used to indicate, if the rule application shall break up if a rule would + * be feasible if further data was available, or not. + */ + public void applyRules(ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize) + { + applyRules(parent, builder, nodeFactory, finalize, ""); + } + + /** + *+ * applies the known rules to the provided parent node. For the creation of further nodes, + * the provided builder and node factory are utilized. If the finalize parameter is true, the + * rule application is finalized as far as possible without waiting for further data. If it is + * false, the rule application is broken up at the first rule returning, that its application + * would be feasible. The method calls itself for each parent node created through the rule + * application. In this case, the finalize parameter is always true. + *
+ * + * @param parent the parent node to apply the rules on + * @param builder the task tree builder to be used for linking task tree nodes with each + * other + * @param nodeFactory the node factory to be used for instantiating new task tree nodes. + * @param finalize used to indicate, if the rule application shall break up if a rule would + * be feasible if further data was available, or not. + * @param logIndent simply used for loggin purposes to indent the log messages depending + * on the recursion depth of calling this method. + */ + private int applyRules(ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize, + String logIndent) + { + Console.traceln(Level.FINER, logIndent + "applying rules for " + parent); + + int noOfRuleApplications = 0; + + for (TemporalRelationshipRule rule : rules) { + RuleApplicationResult result; + do { + // LOG.info(logIndent + "trying to apply rule " + rule + " on " + parent); + result = rule.apply(parent, builder, nodeFactory, finalize); + + if ((result != null) && + (result.getRuleApplicationStatus() == + RuleApplicationStatus.RULE_APPLICATION_FINISHED)) + { + Console.traceln + (Level.FINE, logIndent + "applied rule " + rule + " on " + parent); + noOfRuleApplications++; + + for (ITaskTreeNode newParent : result.getNewlyCreatedParentNodes()) { + noOfRuleApplications += + applyRules(newParent, builder, nodeFactory, true, logIndent + " "); + } + } + } + while ((result != null) && + (result.getRuleApplicationStatus() == + RuleApplicationStatus.RULE_APPLICATION_FINISHED)); + + if ((!finalize) && + (result != null) && + (result.getRuleApplicationStatus() == + RuleApplicationStatus.RULE_APPLICATION_FEASIBLE)) + { + // in this case, don't go on applying rules, which should not be applied yet + break; + } + } + + if (noOfRuleApplications <= 0) { + Console.traceln(Level.INFO, logIndent + "no rules applied --> no temporal " + + "relationship generated"); + } + + return noOfRuleApplications; + } + + /** + * + */ + /* + * private void dumpTask(TaskTreeNode task, String indent) { System.err.print(indent); + * System.err.print(task); System.err.println(" "); + * + * if ((task.getChildren() != null) && (task.getChildren().size() > 0)) { for (TaskTreeNode + * child : task.getChildren()) { dumpTask(child, indent + " "); } } } + */ + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java (revision 893) @@ -0,0 +1,147 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.eventcore.gui.ValueSelection; +import de.ugoe.cs.quest.eventcore.guimodel.ITrackBar; +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEquality; +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class TrackBarSelectionDetectionRule implements TemporalRelationshipRule { + + /** */ + private NodeEqualityRuleManager nodeEqualityRuleManager; + + /** + * TODO: comment + * + */ + TrackBarSelectionDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager) { + super(); + this.nodeEqualityRuleManager = nodeEqualityRuleManager; + } + + /* + * (non-Javadoc) + * + * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof ISequence)) { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + int valueSelectionStartIndex = -1; + + int index = 0; + while (index < parent.getChildren().size()) { + ITaskTreeNode child = parent.getChildren().get(index); + + if ((child instanceof IEventTask) && + (((IEventTask) child).getEventTarget() instanceof ITrackBar) && + (((IEventTask) child).getEventType() instanceof ValueSelection)) + { + if (valueSelectionStartIndex < 0) { + // let the show begin + valueSelectionStartIndex = index; + } + } + else if (valueSelectionStartIndex >= 0) { + // current child is no more value selection. But the preceding tasks were. + // Therefore, + // create an iteration with the different selectable values as selection children + handleValueSelections(valueSelectionStartIndex, index - 1, parent, builder, + nodeFactory, result); + + return result; + } + + index++; + } + + if (valueSelectionStartIndex >= 0) { + if (finalize) { + handleValueSelections(valueSelectionStartIndex, parent.getChildren().size() - 1, + parent, builder, nodeFactory, result); + } + else { + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + } + + return result; + } + + /** + * TODO: comment + * + * @param valueSelectionStartIndex + * @param i + */ + private void handleValueSelections(int startIndex, + int endIndex, + ITaskTreeNode parent, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + IIteration iteration = nodeFactory.createNewIteration(); + result.addNewlyCreatedParentNode(iteration); + + ISelection selection = nodeFactory.createNewSelection(); + result.addNewlyCreatedParentNode(selection); + builder.setChild(iteration, selection); + + for (int i = endIndex - startIndex; i >= 0; i--) { + addChildIfNecessary(selection, parent.getChildren().get(startIndex), builder, + nodeFactory, result); + builder.removeChild((ISequence) parent, startIndex); + } + + builder.addChild((ISequence) parent, startIndex, iteration); + + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + } + + /** + * + */ + private void addChildIfNecessary(ISelection parentSelection, + ITaskTreeNode node, + ITaskTreeBuilder builder, + ITaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + for (int i = 0; i < parentSelection.getChildren().size(); i++) { + ITaskTreeNode child = parentSelection.getChildren().get(i); + + // check, if the new node is a variant for the current event task + NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules(child, node); + if (nodeEquality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) { + return; + } + } + + // if we did not return in the previous checks, then the node must be added + builder.addChild(parentSelection, node); + } + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/IEventTask.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/IEventTask.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/IEventTask.java (revision 893) @@ -0,0 +1,31 @@ +package de.ugoe.cs.quest.tasktrees.treeifc; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; + +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +public interface IEventTask extends ITaskTreeNode { + + /** + * @return Returns the event type. + */ + public IEventType getEventType(); + + /** + * @return Returns the event target. + */ + public IEventTarget getEventTarget(); + + /** + * TODO: comment + * + * @return + */ + public IEventTask clone(); + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/IIteration.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/IIteration.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/IIteration.java (revision 893) @@ -0,0 +1,18 @@ +package de.ugoe.cs.quest.tasktrees.treeifc; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public interface IIteration extends ITemporalRelationship { + + /** + * TODO: comment + * + * @return + */ + public IIteration clone(); + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ISelection.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ISelection.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ISelection.java (revision 893) @@ -0,0 +1,18 @@ +package de.ugoe.cs.quest.tasktrees.treeifc; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public interface ISelection extends ITemporalRelationship { + + /** + * TODO: comment + * + * @return + */ + public ISelection clone(); + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ISequence.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ISequence.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ISequence.java (revision 893) @@ -0,0 +1,18 @@ +package de.ugoe.cs.quest.tasktrees.treeifc; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public interface ISequence extends ITemporalRelationship { + + /** + * TODO: comment + * + * @return + */ + public ISequence clone(); + +} Index: /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ITaskTree.java =================================================================== --- /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ITaskTree.java (revision 893) +++ /trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/ITaskTree.java (revision 893) @@ -0,0 +1,31 @@ +package de.ugoe.cs.quest.tasktrees.treeifc; + +import java.util.Map; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public interface ITaskTree extends Cloneable { + + /** + * TODO: comment + * + * @return + */ + public ITaskTreeNode getRoot(); + + /** + * TODO: comment + * + * @return + */ + public Map