+ * TODO comment + *
+ * + * @author Patrick Harms + */ +public class TaskTreeNodeMergerTest { + + /** */ + private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); + + /** */ + private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); + + /** */ + private NodeEqualityRuleManager nodeEqualityRuleManager = + Utilities.getNodeEqualityRuleManagerForTests(); + + /** + * + */ + @Test + public void test_EventTaskMerge_1() { + String spec1 = "EventTask target1 {}"; + String spec2 = "EventTask target1 {}"; + + String oracleSpec = "EventTask target1 {}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_2() { + String spec1 = "EventTask target1 {}"; + String spec2 = "EventTask target2 {}"; + + String oracleSpec = + "Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_3() { + String spec1 = + "Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String spec2 = "EventTask target2 {}"; + + String oracleSpec = + "Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_4() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String oracleSpec = + "Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_5() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Iteration {" + + " EventTask target1 {}" + + "}"; + + String oracleSpec = + "Iteration {" + + " EventTask target1 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_6() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Iteration {" + + " Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + String oracleSpec = + "Iteration {" + + " Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_7() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Iteration {" + + " Selection {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + String oracleSpec = + "Iteration {" + + " Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_8() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String oracleSpec = + "Selection {" + + " EventTask target1 {}" + + " Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_EventTaskMerge_9() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " EventTask target1 {}" + + " Optional {" + + " EventTask target2 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_1() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_2() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target4 {}" + + " EventTask target3 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " EventTask target1 {}" + + " Selection {" + + " EventTask target2 {}" + + " EventTask target4 {}" + + " }" + + " EventTask target3 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_3() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target4 {}" + + " EventTask target5 {}" + + " EventTask target6 {}" + + "}"; + + String oracleSpec = + "Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + " Sequence {" + + " EventTask target4 {}" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_4() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target4 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " Selection {" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_5() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target4 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " Selection {" + + " EventTask target1 {}" + + " EventTask target4 {}" + + " }" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_6() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target4 {}" + + " EventTask target2 {}" + + " EventTask target5 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " Selection {" + + " EventTask target1 {}" + + " EventTask target4 {}" + + " }" + + " EventTask target2 {}" + + " Selection {" + + " EventTask target3 {}" + + " EventTask target5 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_7() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target3 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " EventTask target1 {}" + + " Optional {" + + " EventTask target2 {}" + + " }" + + " EventTask target3 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_8() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " Optional {" + + " EventTask target3 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_9() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " Optional {" + + " EventTask target1 {}" + + " }" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_10() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target2 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " Optional {" + + " EventTask target1 {}" + + " }" + + " EventTask target2 {}" + + " Optional {" + + " EventTask target3 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SequenceMerge_11() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " EventTask target7 {}" + + "}"; + + String spec2 = + "Sequence {" + + " EventTask target4 {}" + + " EventTask target3 {}" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " EventTask target4 {}" + + " EventTask target2 {}" + + " EventTask target6 {}" + + " EventTask target7 {}" + + "}"; + + String oracleSpec = + "Sequence {" + + " Optional {" + + " Sequence {" + + " EventTask target4 {}" + + " EventTask target3 {}" + + " }" + + " }" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " Selection {" + + " EventTask target5 {}" + + " Sequence {" + + " EventTask target4 {}" + + " EventTask target2 {}" + + " }" + + " }" + + " EventTask target6 {}" + + " EventTask target7 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SelectionMerge_1() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Selection {" + + " EventTask target1 {}" + + "}"; + + String oracleSpec = + "Selection {" + + " EventTask target1 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SelectionMerge_2() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Selection {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + String oracleSpec = + "Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SelectionMerge_3() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Selection {" + + " Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + String oracleSpec = + "Selection {" + + " EventTask target1 {}" + + " Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SelectionMerge_4() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + String oracleSpec = + "Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " Optional {" + + " EventTask target2 {}" + + " }" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SelectionMerge_5() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String spec2 = + "Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + String oracleSpec = + "Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_SelectionMerge_6() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String spec2 = + "Selection {" + + " Sequence {" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " }" + + " Sequence {" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " }" + + "}"; + + String oracleSpec = + "Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + " Sequence {" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " }" + + " Sequence {" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_IterationMerge_1() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Iteration {" + + " EventTask target1 {}" + + "}"; + + String oracleSpec = + "Iteration {" + + " EventTask target1 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_IterationMerge_2() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Iteration {" + + " Selection {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + String oracleSpec = + "Iteration {" + + " Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_IterationMerge_3() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Iteration {" + + " Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + String oracleSpec = + "Iteration {" + + " Selection {" + + " EventTask target1 {}" + + " Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_IterationMerge_4() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Iteration {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + String oracleSpec = + "Iteration {" + + " Sequence {" + + " EventTask target1 {}" + + " Optional {" + + " EventTask target2 {}" + + " }" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_IterationMerge_5() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String spec2 = + "Iteration {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + String oracleSpec = + "Iteration {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_IterationMerge_6() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String spec2 = + "Iteration {" + + " Selection {" + + " Sequence {" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " }" + + " Sequence {" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " }" + + " }" + + "}"; + + String oracleSpec = + "Iteration {" + + " Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + " Sequence {" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " }" + + " Sequence {" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " }" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_OptionalMerge_1() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Optional {" + + " EventTask target1 {}" + + "}"; + + String oracleSpec = + "Optional {" + + " EventTask target1 {}" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_OptionalMerge_2() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Optional {" + + " Selection {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + String oracleSpec = + "Optional {" + + " Selection {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_OptionalMerge_3() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Optional {" + + " Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + "}"; + + String oracleSpec = + "Optional {" + + " Selection {" + + " EventTask target1 {}" + + " Sequence {" + + " EventTask target2 {}" + + " EventTask target3 {}" + + " }" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_OptionalMerge_4() { + String spec1 = "EventTask target1 {}"; + + String spec2 = + "Optional {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + String oracleSpec = + "Optional {" + + " Sequence {" + + " EventTask target1 {}" + + " Optional {" + + " EventTask target2 {}" + + " }" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_OptionalMerge_5() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String spec2 = + "Optional {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + String oracleSpec = + "Optional {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + @Test + public void test_OptionalMerge_6() { + String spec1 = + "Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + "}"; + + String spec2 = + "Optional {" + + " Selection {" + + " Sequence {" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " }" + + " Sequence {" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " }" + + " }" + + "}"; + + String oracleSpec = + "Optional {" + + " Selection {" + + " Sequence {" + + " EventTask target1 {}" + + " EventTask target2 {}" + + " }" + + " Sequence {" + + " EventTask target3 {}" + + " EventTask target4 {}" + + " }" + + " Sequence {" + + " EventTask target5 {}" + + " EventTask target6 {}" + + " }" + + " }" + + "}"; + + performTest(spec1, spec2, oracleSpec); + } + + /** + * + */ + private void performTest(String spec1, String spec2, String specOracle) { + TaskTreeInstantiator instantiator = + new TaskTreeInstantiator(taskTreeNodeFactory, taskTreeBuilder); + + ITaskTreeNode node1 = instantiator.instantiateTaskTree(spec1); + ITaskTreeNode node2 = instantiator.instantiateTaskTree(spec2); + ITaskTreeNode oracle = instantiator.instantiateTaskTree(specOracle); + + TaskTreeNodeComparator comparator = + new TaskTreeNodeComparator(nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL); + + TaskTreeNodeMerger merger = new TaskTreeNodeMerger + (taskTreeNodeFactory, taskTreeBuilder, comparator); + + try { + ITaskTreeNode result = merger.mergeTaskNodes(node1, node2); + new TaskTreeChecker().assertTaskNodesEqual(oracle, result); + } + catch (AssertionError e) { + AssertionError toThrow = new AssertionError("first check: " + e.getMessage()); + toThrow.setStackTrace(e.getStackTrace()); + throw toThrow; + } + + node1 = instantiator.instantiateTaskTree(spec1); + node2 = instantiator.instantiateTaskTree(spec2); + oracle = instantiator.instantiateTaskTree(specOracle); + + comparator = + new TaskTreeNodeComparator(nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL); + + merger = new TaskTreeNodeMerger(taskTreeNodeFactory, taskTreeBuilder, comparator); + + try { + ITaskTreeNode result = merger.mergeTaskNodes(node2, node1); + new TaskTreeChecker().assertTaskNodesEqual(oracle, result); + } + catch (AssertionError e) { + AssertionError toThrow = new AssertionError("second check: " + e.getMessage()); + toThrow.setStackTrace(e.getStackTrace()); + throw toThrow; + } + } +} Index: trunk/autoquest-core-tasktrees/pom.xml =================================================================== --- trunk/autoquest-core-tasktrees/pom.xml (revision 1126) +++ trunk/autoquest-core-tasktrees/pom.xml (revision 1127) @@ -28,4 +28,9 @@- * the task tree node factory to be used for creating substructures for the temporal - * relationships identified during rule - *
- */ - private ITaskTreeNodeFactory taskTreeNodeFactory; - /** - *- * the task tree builder to be used for creating substructures for the temporal relationships - * identified during rule application - *
- */ - private ITaskTreeBuilder taskTreeBuilder; - - /** - *- * instantiates the rule with a task tree node factory and builder to be used during rule - * application. - *
- * - * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures - * for the temporal relationships identified during rule - * application - * @param taskTreeBuilder the task tree builder to be used for creating substructures for - * the temporal relationships identified during rule application - */ - DefaultEventTargetSequenceDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory, - ITaskTreeBuilder taskTreeBuilder) - { - this.taskTreeNodeFactory = taskTreeNodeFactory; - this.taskTreeBuilder = taskTreeBuilder; - } - - /* (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return "DefaultEventTargetSequenceDetectionRule"; - } - - /* - * (non-Javadoc) - * - * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, - * boolean) - */ - @Override - public RuleApplicationResult apply(ITaskTreeNode parent, 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, currentEventTarget, startingIndex, endIndex, result); - - result.setRuleApplicationStatus - (RuleApplicationStatus.RULE_APPLICATION_FINISHED); - return result; - } - else if (eventTarget != null) { - // here a new sequence on a new target begins - startingIndex = index; - currentEventTarget = eventTarget; - } - else { - startingIndex = -1; - currentEventTarget = null; - } - } - } - - 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, currentEventTarget, startingIndex, endIndex, result); - - result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); - } - } - else { - result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); - } - } - - return result; - } - - /** - * - */ - 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; - } - } - - /** - * - */ - private void handleEventTargetSequence(ITaskTreeNode parent, - IEventTarget target, - int startIndex, - int endIndex, - RuleApplicationResult result) - { - String description = "interactions on " + target.getStringIdentifier(); - - ISequence sequence = RuleUtils.createNewSubSequenceInRange - (parent, startIndex, endIndex, description, taskTreeNodeFactory, taskTreeBuilder); - - result.addNewlyCreatedParentNode(sequence); - } - -} Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java =================================================================== --- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java (revision 1126) +++ (revision ) @@ -1,498 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import java.util.ArrayList; -import java.util.List; - -import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement; -import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; - -/** - * This rule structures the task tree based on GUI elements of the GUI model. The rule can - * be provided with a filter for considered GUI elements. It generates sub sequences for any - * GUI element in the hierarchy matching the filter so that each sequence represents all - * interactions in a certain GUI element. - * - * @version $Revision: $ $Date: 18.03.2012$ - * @author 2012, last modified by $Author: patrick$ - */ -class DefaultGuiElementSequenceDetectionRule implements TemporalRelationshipRule { - - /** - *- * the task tree node factory to be used for creating substructures for the temporal - * relationships identified during rule - *
- */ - private ITaskTreeNodeFactory taskTreeNodeFactory; - /** - *- * the task tree builder to be used for creating substructures for the temporal relationships - * identified during rule application - *
- */ - private ITaskTreeBuilder taskTreeBuilder; - - /** - *- * the GUI element filter to be applied or null if none is specified. - *
- */ - private List- * instantiates the rule with a task tree node factory and builder to be used during rule - * application but without a GUI element filter - *
- * - * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures - * for the temporal relationships identified during rule - * application - * @param taskTreeBuilder the task tree builder to be used for creating substructures for - * the temporal relationships identified during rule application - */ - DefaultGuiElementSequenceDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory, - ITaskTreeBuilder taskTreeBuilder) - { - this(null, taskTreeNodeFactory, taskTreeBuilder); - } - - /** - *- * instantiates the rule with a GUI element filter. Only those types given in the filter will - * be considered during the rule application. For all other types, no subsequences will be - * created. - *
- * - * @param guiElementFilter the GUI element filter to be applied - * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures - * for the temporal relationships identified during rule - * application - * @param taskTreeBuilder the task tree builder to be used for creating substructures for - * the temporal relationships identified during rule application - */ - DefaultGuiElementSequenceDetectionRule(List- * generates subsequences for all groups of children of the provided parent, that operate - * in different GUI elements at the provided hierarchy level. It will not generate a sub - * sequence for the last elements, if the rule application shall not finalize. - *
- * - * @param parent the parent node of which the children shall be grouped - * @param hierarchies the GUI hierarchies for the children of the parent - * @param hierarchyLevel the current hierarchy level to be considered - * @param maxHierarchyDepth the maximum hierarchy depth that may apply in this application - * @param finalize true, if the application shall be finalized, false else - * @param result the result of the rule application to add newly created parent - * nodes to - * - * @return RULE_APPLICATION_FINISHED, if at least one subsequence was generated, - * RULE_APPLICATION_FEASIBLE, if the application shall not be finalized but some - * children could be condensed if further data was available, and RULE_NOT_APPLIED, - * if no subsequence was created and none is can be created, because no further - * data is expected - */ - private RuleApplicationStatus generateSubSequences(ITaskTreeNode parent, - List- * condenses a specified group of children on the provided parent to a subsequences and - * calls {@link #generateSubSequences(ITaskTreeNode, List, int, boolean, ITaskTreeBuilder, ITaskTreeNodeFactory, RuleApplicationResult)} - * for the newly created subsequence. The method does not condense subgroups consisting of - * only one child which is already a sequence. - *
- * - * @param parent the parent task of which children shall be condensed - * @param hierarchies the GUI element hierarchies of the children of the parent - * @param hierarchyLevel the currently considered GUI element hierarchy level - * @param startIndex the index of the first child belonging to the subgroup - * @param endIndex the index of the last child belonging to the subgroup - * @param result the result of the rule application to add newly created parent nodes to - * - * @return RULE_APPLICATION_FINISHED, if at the subsequence was generated and RULE_NOT_APPLIED, - * if no subsequence was created, because only one child belonged to the group which - * was already a sequence - */ - private RuleApplicationStatus condenseSequence(ITaskTreeNode parent, - List- * return a common denominator for the provided list of GUI elements, i.e. a GUI element, that - * is part of the parent GUI hiearchy of all GUI elements in the list. If there is no common - * denominator, the method returns null. - *
- */ - private IGUIElement getCommonDenominator(List- * returns the GUI element on which all interactions of the provided task takes place. If - * the task is a simple event task its target is returned. If the task is a parent task - * of several children, the common denominator of the GUI elements of all its children is - * returned. The method returns null, if there is no common GUI element for all events - * represented by the provided task. - *
- */ - private IGUIElement getGuiElement(ITaskTreeNode node) { - if (node != null) { - List- * recursive method calling itself to determine all terminal GUI elements of the provided - * task. The terminal GUI elements are stored in the provided list. - *
- */ - private void getTerminalGuiElements(ITaskTreeNode node, List- * returns a list of GUI elements that represents the whole GUI element hierarchy of the - * provided GUI element. The method considers the GUI element filter applied by this rule. - *
- */ - private List- * returns for a given GUI element the next GUI element in the upper GUI element hierarchy - * that matches the GUI element filter of the rule. If the provided GUI element already - * matches the filter, it is returned directly. - *
- */ - private IGUIElement searchHierarchyForGuiElementWithConsideredType(IGUIElement guiElement) { - IGUIElement returnValue = guiElement; - - while ((returnValue != null) && !guiElementMatchesConsideredTypes(returnValue)) { - returnValue = returnValue.getParent(); - } - - return returnValue; - } - - /** - *- * checks if the provided GUI element matches the GUI element filter applied by the rule. - *
- */ - private boolean guiElementMatchesConsideredTypes(IGUIElement guiElement) { - if (guiElementFilter == null) { - return true; - } - else { - for (Class clazz : guiElementFilter) { - if (clazz.isInstance(guiElement)) { - return true; - } - } - - return false; - } - } - -} Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java =================================================================== --- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java (revision 1126) +++ (revision ) @@ -1,199 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import java.util.Stack; - -import de.ugoe.cs.autoquest.eventcore.gui.IInteraction; -import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; - -/** - * This rule generates sequences of events depending on the event types, more concrete, the - * {@link IInteraction}s and the return values of their {@link IInteraction#startsLogicalSequence()} - * and {@link IInteraction#finishesLogicalSequence()}. If a new logical sequence is started by - * an interaction, then a real sequence is instantiated. The sequence is finished, if an - * interaction finishes a logical sequence. Examples include keyboard focus changes. - * - * @version $Revision: $ $Date: 18.03.2012$ - * @author 2012, last modified by $Author: patrick$ - */ -class DefaultGuiEventSequenceDetectionRule implements TemporalRelationshipRule { - - /** - *- * the task tree node factory to be used for creating substructures for the temporal - * relationships identified during rule - *
- */ - private ITaskTreeNodeFactory taskTreeNodeFactory; - /** - *- * the task tree builder to be used for creating substructures for the temporal relationships - * identified during rule application - *
- */ - private ITaskTreeBuilder taskTreeBuilder; - - /** - *- * instantiates the rule with a task tree node factory and builder to be used during rule - * application. - *
- * - * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures - * for the temporal relationships identified during rule - * application - * @param taskTreeBuilder the task tree builder to be used for creating substructures for - * the temporal relationships identified during rule application - */ - DefaultGuiEventSequenceDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory, - ITaskTreeBuilder taskTreeBuilder) - { - this.taskTreeNodeFactory = taskTreeNodeFactory; - this.taskTreeBuilder = taskTreeBuilder; - } - - /* (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return "DefaultGuiEventSequenceDetectionRule"; - } - - /* - * (non-Javadoc) - * - * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, - * boolean) - */ - @Override - public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { - if (!(parent instanceof ISequence)) { - return null; - } - - RuleApplicationResult result = new RuleApplicationResult(); - Stack- * TODO: comment - *
- * - */ - private int handleLogicalSequence(Stack- * 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 maximum length for iterated sequences - *
- */ - private static final int MAX_LENGTH_OF_ITERATED_SEQUENCE = 50; - - /** - *- * the task tree node factory to be used for creating substructures for the temporal - * relationships identified during rule - *
- */ - private ITaskTreeNodeFactory taskTreeNodeFactory; - /** - *- * the task tree builder to be used for creating substructures for the temporal relationships - * identified during rule application - *
- */ - private ITaskTreeBuilder taskTreeBuilder; - - /** - *- * 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, - ITaskTreeNodeFactory taskTreeNodeFactory, - ITaskTreeBuilder taskTreeBuilder) - { - this.nodeEqualityRuleManager = nodeEqualityRuleManager; - this.minimalNodeEquality = minimalNodeEquality; - this.taskTreeNodeFactory = taskTreeNodeFactory; - this.taskTreeBuilder = taskTreeBuilder; - } - - /* (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return "DefaultIterationDetectionRule"; - } - - /* - * (non-Javadoc) - * - * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, - * boolean) - */ - @Override - public RuleApplicationResult apply(ITaskTreeNode parent, 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; - } - - - SubSequences subSequences = getEqualSubsequences(parent); - - if (subSequences != null) { - RuleApplicationResult result = new RuleApplicationResult(); - - mergeEqualNodes(subSequences.equalVariants); - IIteration newIteration = - createIterationBasedOnIdentifiedVariants(subSequences, result); - - determineNewlyCreatedParentTasks(parent, newIteration, result); - - // remove iterated children - for (int j = subSequences.start; j < subSequences.end; j++) { - taskTreeBuilder.removeChild((ISequence) parent, subSequences.start); - } - - // add the new iteration instead - taskTreeBuilder.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 - * - * @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) { - SubSequences subSequences = null; - - // to find longer iterations first, start with long sequences - 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, 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 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, - boolean useEqualSublistLengths) - { - boolean foundFurtherVariants = (start == end) && (subSequences.equalVariants.size() > 1); - - int minChildCount = 1; - int maxChildCount = Math.min(MAX_LENGTH_OF_ITERATED_SEQUENCE, 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 = taskTreeNodeFactory.createNewSequence(); - - for (int j = start; j < start + childCount; j++) { - taskTreeBuilder.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, 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 - */ - 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 - * - * @return the result of the merge - */ - private ITaskTreeNode mergeEqualTasks(ITaskTreeNode node1, ITaskTreeNode node2) { - ITaskTreeNode mergeResult = null; - - if ((node1 instanceof ISequence) && (node2 instanceof ISequence)) { - mergeResult = mergeEqualSequences((ISequence) node1, (ISequence) node2); - } - else if ((node1 instanceof ISelection) && (node2 instanceof ISelection)) { - mergeResult = mergeEqualSelections((ISelection) node1, (ISelection) node2); - } - else if ((node1 instanceof IIteration) && (node2 instanceof IIteration)) { - mergeResult = mergeEqualIterations((IIteration) node1, (IIteration) node2); - } - else if (node1 instanceof ISelection) { - taskTreeBuilder.addChild((ISelection) node1, node2); - mergeResult = node1; - } - else if (node2 instanceof ISelection) { - taskTreeBuilder.addChild((ISelection) node2, node1); - mergeResult = node2; - } - else if (node1 instanceof IIteration) { - mergeResult = mergeEqualTasks(((IIteration) node1).getChildren().get(0), node2); - - if (mergeResult != null) { - IIteration iteration = taskTreeNodeFactory.createNewIteration(); - taskTreeBuilder.setChild(iteration, mergeResult); - mergeResult = iteration; - } - } - else if (node2 instanceof IIteration) { - mergeResult = mergeEqualTasks(((IIteration) node2).getChildren().get(0), node1); - - if (mergeResult != null) { - IIteration iteration = taskTreeNodeFactory.createNewIteration(); - taskTreeBuilder.setChild(iteration, mergeResult); - mergeResult = iteration; - } - } - else { - NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules(node1, node2); - - if (nodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)) { - mergeResult = node1; - } - } - - if (mergeResult == null) { - mergeResult = taskTreeNodeFactory.createNewSelection(); - taskTreeBuilder.addChild((ISelection) mergeResult, node1); - taskTreeBuilder.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 - * - * @return the result of the merge or null if merging was not possible - */ - private ISequence mergeEqualSequences(ISequence sequence1, ISequence sequence2) { - ISequence mergeResult = null; - - if (sequence1.getChildren().size() == sequence2.getChildren().size()) { - mergeResult = taskTreeNodeFactory.createNewSequence(); - - for (int i = 0; i < sequence1.getChildren().size(); i++) { - ITaskTreeNode mergedNode = mergeEqualTasks - (sequence1.getChildren().get(i), sequence2.getChildren().get(i)); - - if (mergedNode != null) { - taskTreeBuilder.addChild(mergeResult, mergedNode); - } - else { - mergeResult = null; - break; - } - } - } - - return mergeResult; - } - - /** - *- * merges equal selections. This is done by adding those children of the second selection to - * the first selection that can not be merged with any of the children of the first selection. - * If a merge is possible and this merge is not a simple selection of the merged children, - * then the merged child replaces the child of the first selection which was merged. - *
- * - * @param selection1 the first selection to be merged - * @param selection2 the second selection to be merged - * - * @return the result of the merge which is never null - */ - private ITaskTreeNode mergeEqualSelections(ISelection selection1, ISelection selection2) { - ISelection mergeResult = selection1; - - ITaskTreeNode childToMerge = null; - ITaskTreeNode mergedChild = null; - - // check for each child of selection 2 if it is a duplicate of one of the children - // if selection 1. If not, add it as further child to the merge result, else skip it. - for (int i = 0; i < selection2.getChildren().size(); i++) { - childToMerge = selection2.getChildren().get(i); - for (int j = 0; j < selection1.getChildren().size(); j++) { - mergedChild = mergeEqualTasks(selection1.getChildren().get(j), childToMerge); - - // a merge must not be a selection, except it is one of the children. Otherwise - // no real merge was done. - if ((mergedChild != null) && - ((!(mergedChild instanceof ISelection)) || - (selection1.getChildren().get(j) == mergedChild) || - (childToMerge == mergedChild))) - { - // we found a real merge. So replace the original child in selection 1 with - // the merged child - taskTreeBuilder.removeChild(selection1, selection1.getChildren().get(j)); - taskTreeBuilder.addChild(selection1, mergedChild); - mergedChild = null; - childToMerge = null; - break; - } - } - - if (childToMerge != null) { - taskTreeBuilder.addChild(selection1, childToMerge); - } - } - - 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 - * - * @return the result of the merge or null if merging is not possible - */ - private ITaskTreeNode mergeEqualIterations(IIteration iteration1, IIteration iteration2) { - ITaskTreeNode mergedChild = mergeEqualTasks - (iteration1.getChildren().get(0), iteration2.getChildren().get(0)); - - IIteration mergeResult = null; - - if (mergedChild != null) { - mergeResult = taskTreeNodeFactory.createNewIteration(); - taskTreeBuilder.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 - * - * @return the resulting iteration - */ - private IIteration createIterationBasedOnIdentifiedVariants(SubSequences subsequences, - RuleApplicationResult result) - { - IIteration newIteration = taskTreeNodeFactory.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 - taskTreeBuilder.setChild - (newIteration, subsequences.equalVariants.get(0).getChildren().get(0)); - } - else { - // there was an iteration of one equal sequence - taskTreeBuilder.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 = taskTreeNodeFactory.createNewSelection(); - result.addNewlyCreatedParentNode(selection); - - for (ITaskTreeNode variant : subsequences.equalVariants) { - if (variant.getChildren().size() == 1) { - taskTreeBuilder.addChild(selection, variant.getChildren().get(0)); - } - else { - taskTreeBuilder.addChild(selection, variant); - result.addNewlyCreatedParentNode(variant); - } - } - - taskTreeBuilder.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- * TODO comment - *
- * - * @author Patrick Harms - */ -class DefaultTaskSequenceDetectionRule implements TemporalRelationshipRule { - - /** - *- * the task tree node factory to be used for creating substructures for the temporal - * relationships identified during rule - *
- */ - private ITaskTreeNodeFactory taskTreeNodeFactory; - /** - *- * the task tree builder to be used for creating substructures for the temporal relationships - * identified during rule application - *
- */ - private ITaskTreeBuilder taskTreeBuilder; - - /** - *- * the node comparator to be used for comparing task tree nodes - *
- */ - private SymbolComparator- * 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. - *
- */ - DefaultTaskSequenceDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager, - NodeEquality minimalNodeEquality, - ITaskTreeNodeFactory taskTreeNodeFactory, - ITaskTreeBuilder taskTreeBuilder) - { - this.taskTreeNodeFactory = taskTreeNodeFactory; - this.taskTreeBuilder = taskTreeBuilder; - - this.nodeComparator = - new TaskTreeNodeComparator(nodeEqualityRuleManager, minimalNodeEquality); - } - - /* (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return "DefaultTaskSequenceDetectionRule"; - } - - /* - * (non-Javadoc) - * - * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, - * boolean) - */ - @Override - public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { - if (!(parent instanceof ISequence)) { - return null; - } - - if (!finalize) { - // the rule is always feasible as tasks may occur at any time - RuleApplicationResult result = new RuleApplicationResult(); - result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); - return result; - } - - RuleApplicationData- * TODO: comment - *
- * - * @param i - * @return - */ - private void getSequencesOccuringMostOften(RuleApplicationData- * TODO: comment - *
- * - * @param parent - * @return - */ - private void createNewTrie(RuleApplicationData- * TODO: comment - *
- * - * @param trie - * @param parent - */ - private void trainTrie(ITaskTreeNode parent, RuleApplicationData- * TODO: comment - *
- * - * @param task - * @param parent - * @param treeBuilder - * @param nodeFactory - * @param result - */ - private void createSequenceForTaskOccurrences(String taskId, - List- * TODO: comment - *
- * - * @param trie - * @param object - * @return - */ - private int getSubListIndex(List- * TODO comment - *
- * - * @author Patrick Harms - */ - private class MaxCountAndLongestSequenceFinder implements TrieProcessor- * TODO: comment - *
- * - * @param maxCount - */ - public MaxCountAndLongestSequenceFinder(int maxCount) { - super(); - this.maxCount = maxCount; - this.currentCount = 0; - } - - /* (non-Javadoc) - * @see de.ugoe.cs.autoquest.usageprofiles.TrieProcessor#process(java.util.List, int) - */ - @Override - public TrieProcessor.Result process(List- * TODO: comment - *
- * - * @return - */ - public Sequences- * TODO: comment - *
- * - */ - private void removePermutationsOfShorterTasks() { - // now iterate the sorted list and for each task remove all other tasks that are shorter - // (i.e. come later in the sorted list) and that represent a subpart of the task - for (int i = 0; i < foundSequences.size(); i++) { - for (int j = i + 1; j < foundSequences.size();) { - if (foundSequences.get(j).size() < foundSequences.get(i).size()) { - // found a task that is a potential subtask. Check for this and remove the - // subtask if needed - List- * TODO comment - *
- * - * @author Patrick Harms - */ - private class Sequences- * TODO: comment - *
- * - * @param occurrenceCount - * @param sequences - */ - private Sequences(int occurrenceCount, List- * TODO: comment - *
- * - * @return - */ - private int getOccurrenceCount() { - return occurrenceCount; - } - - /** - *- * TODO: comment - *
- * - * @return - */ - private int size() { - return this.sequences.size(); - } - - /** - * - */ - - /* (non-Javadoc) - * @see java.lang.Iterable#iterator() - */ - @Override - public Iterator+ * 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 maximum length for iterated sequences + *
+ */ + private static final int MAX_LENGTH_OF_ITERATED_SEQUENCE = 50; + + /** + *+ * the task tree node factory to be used for creating substructures for the temporal + * relationships identified during rule + *
+ */ + private ITaskTreeNodeFactory taskTreeNodeFactory; + /** + *+ * the task tree builder to be used for creating substructures for the temporal relationships + * identified during rule application + *
+ */ + private ITaskTreeBuilder taskTreeBuilder; + + /** + *+ * the node comparator used for comparing task tree nodes with each other + *
+ */ + private TaskTreeNodeComparator nodeComparator; + + /** + *+ * 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. + *
+ */ + IterationOfSubtreesDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager, + NodeEquality minimalNodeEquality, + ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + + this.nodeComparator = + new TaskTreeNodeComparator(nodeEqualityRuleManager, 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. + *
+ */ + IterationOfSubtreesDetectionRule(TaskTreeNodeComparator nodeComparator, + ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this.nodeComparator = nodeComparator; + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + } + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return "IterationOfSubtreesDetectionRule"; + } + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * boolean) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, 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.FEASIBLE); + return result; + } + + List+ * 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 the provided list of nodes 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 nodes the list of nodes in which iterations shall be found + * + * @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(List+ * 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 nodes in the provided list 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 nodes in the list in which an iteration shall be searched for are event tasks. + *
+ * + * @param nodes the list of nodes to search for iterations + * @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(List+ * this method starts at a specific position in the provided list of nodes 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 the provided list is not yet reached. + *
+ * + * @param subSequences the sublist found so far against which equality of the next + * sublist must be checked + * @param nodes the list of nodes to be checked for iterations + * @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 list of + * nodes in which iterations are searched for + * @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, + List+ * 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 + * + * @return the resulting iteration + */ + private IIteration createIterationBasedOnIdentifiedVariants(SubSequences subsequences, + RuleApplicationResult result) + { + IIteration newIteration = taskTreeNodeFactory.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 + taskTreeBuilder.setChild + (newIteration, subsequences.equalVariants.get(0).getChildren().get(0)); + } + else { + // there was an iteration of one equal sequence + taskTreeBuilder.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 = taskTreeNodeFactory.createNewSelection(); + result.addNewlyCreatedParentNode(selection); + + for (ITaskTreeNode variant : subsequences.equalVariants) { + if (variant.getChildren().size() == 1) { + taskTreeBuilder.addChild(selection, variant.getChildren().get(0)); + } + else { + taskTreeBuilder.addChild(selection, variant); + result.addNewlyCreatedParentNode(variant); + } + } + + taskTreeBuilder.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 task tree node factory to be used for creating substructures for the temporal + * relationships identified during rule + *
+ */ + private ITaskTreeNodeFactory taskTreeNodeFactory; + /** + *+ * the task tree builder to be used for creating substructures for the temporal relationships + * identified during rule application + *
+ */ + private ITaskTreeBuilder taskTreeBuilder; + + /** + *+ * instantiates the rule with a task tree node factory and builder to be used during rule + * application. + *
+ * + * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures + * for the temporal relationships identified during rule + * application + * @param taskTreeBuilder the task tree builder to be used for creating substructures for + * the temporal relationships identified during rule application + */ + SequenceDependingOnEventTypeDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + } + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return "SequenceDependingOnEventTypeDetectionRule"; + } + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * boolean) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { + if (!(parent instanceof ISequence)) { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + Stack+ * TODO: comment + *
+ * + */ + private int handleLogicalSequence(Stack+ * TODO comment + *
+ * + * @author Patrick Harms + */ +class SequenceForTaskDetectionRule implements TemporalRelationshipRule { + + /** + *+ * the task tree node factory to be used for creating substructures for the temporal + * relationships identified during rule + *
+ */ + private ITaskTreeNodeFactory taskTreeNodeFactory; + /** + *+ * the task tree builder to be used for creating substructures for the temporal relationships + * identified during rule application + *
+ */ + private ITaskTreeBuilder taskTreeBuilder; + + /** + *+ * the node comparator to be used for comparing task tree nodes + *
+ */ + private TaskTreeNodeComparator nodeComparator; + + /** + *+ * 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. + *
+ */ + SequenceForTaskDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager, + NodeEquality minimalNodeEquality, + ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + + this.nodeComparator = + new TaskTreeNodeComparator(nodeEqualityRuleManager, minimalNodeEquality); + } + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return "SequenceForTaskDetectionRule"; + } + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * boolean) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { + if (!(parent instanceof ISequence)) { + return null; + } + + if (!finalize) { + // the rule is always feasible as tasks may occur at any time + RuleApplicationResult result = new RuleApplicationResult(); + result.setRuleApplicationStatus(RuleApplicationStatus.FEASIBLE); + return result; + } + + List+ * TODO: comment + *
+ * + * @param appData + */ + private void detectAndReplaceIterations(RuleApplicationData appData) { + System.out.print("detecting iterations"); + appData.getStopWatch().start("detecting iterations"); + + List+ * TODO: comment + *
+ * + * @param appData + */ + private int detectAndReplaceIterations(ISequence session, + RuleApplicationData appData) + { + int count = 0; + + TemporalRelationshipRule rule = new SimpleIterationDetectionRule + (nodeComparator, taskTreeNodeFactory, taskTreeBuilder); + + RuleApplicationResult result = rule.apply(session, true); + + if ((result != null) && (result.getNewlyCreatedParentNodes() != null)) { + for (ITaskTreeNode newParent : result.getNewlyCreatedParentNodes()) { + appData.getResult().addNewlyCreatedParentNode(newParent); + if (newParent instanceof IIteration) { + count++; + } + } + } + + return count; + } + +// /** +// *+// * TODO: comment +// *
+// * +// * @param appData +// */ +// private void mergeEqualTasks(RuleApplicationData appData) { +// System.out.println("merging equal tasks"); +// appData.getStopWatch().start("merging equal tasks"); +// +// int replacements = 0; +// List+ * TODO: comment + *
+ * + * @param appData + */ + private void detectAndReplaceTasks(RuleApplicationData appData) { + System.out.println("detecting and replacing tasks"); + appData.getStopWatch().start("detecting tasks"); + + getSequencesOccuringMostOften(appData); + + appData.getStopWatch().stop("detecting tasks"); + appData.getStopWatch().start("replacing tasks"); + + replaceSequencesOccurringMostOften(appData); + + appData.getStopWatch().stop("replacing tasks"); + System.out.println("detected and replaced " + appData.getLastFoundTasks().size() + " tasks"); + } + + /** + *+ * TODO: comment + *
+ * + * @param i + * @return + */ + private void getSequencesOccuringMostOften(RuleApplicationData appData) { + System.out.println("determining most prominent tasks"); + + Tasks tasks; + boolean createNewTrie = (appData.getLastTrie() == null) || + appData.getReplacementCounter() > 0; // tree has changed + + do { + if (createNewTrie) { + createNewTrie(appData); + } + + MaxCountAndLongestTasksFinder finder = new MaxCountAndLongestTasksFinder(); + appData.getLastTrie().process(finder); + + tasks = finder.getFoundTasks(); + + createNewTrie = false; + + for (List+ * TODO: comment + *
+ * + * @param parent + * @return + */ + private void createNewTrie(RuleApplicationData appData) { + System.out.println("training trie with a maximum sequence length of " + + appData.getTrainedSequenceLength()); + + appData.getStopWatch().start("training trie"); + appData.setLastTrie(new Trie+ * TODO: comment + *
+ * + * @param trie + * @param parent + */ + private void trainTrie(ISequence session, RuleApplicationData appData) { + List+ * TODO: comment + *
+ * + * @param appData + */ + private void replaceSequencesOccurringMostOften(RuleApplicationData appData) { + appData.resetReplacementCounter(); + + if ((appData.getLastFoundTasks().size() > 0) && + (appData.getLastFoundTasks().getOccurrenceCount() > 1)) + { + System.out.println("replacing tasks occurrences with merged variants of all versions"); + + for (List+ * TODO: comment + *
+ * + * @param tree + */ + private void determineVariantsOfTaskOccurrences(List+ * TODO: comment + *
+ * + * @param appData + * @return + */ + private ITaskTreeNode mergeVariantsOfTaskOccurrence(String taskId, + RuleApplicationData appData) + { + return mergeVariantsOfTasks(taskId, appData.getTaskOccurrences()); + } + + /** + *+ * TODO: comment + *
+ * + * @param appData + * @return + */ + private ITaskTreeNode mergeVariantsOfTasks(String description, List+ * TODO: comment + *
+ * + * @param task + * @param parent + * @param treeBuilder + * @param nodeFactory + * @param result + */ + private void replaceTaskOccurrences(List+ * TODO: comment + *
+ * + * @param trie + * @param object + * @return + */ + private int getSubListIndex(List+ * TODO comment + *
+ * + * @author Patrick Harms + */ + private class MaxCountAndLongestTasksFinder implements TrieProcessor+ * TODO: comment + *
+ * + * @param maxCount + */ + public MaxCountAndLongestTasksFinder() { + super(); + this.currentCount = 0; + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.usageprofiles.TrieProcessor#process(java.util.List, int) + */ + @Override + public TrieProcessor.Result process(List+ * TODO: comment + *
+ * + * @return + */ + public Tasks getFoundTasks() { + removePermutationsOfShorterTasks(); + return new Tasks(currentCount, foundTasks); + } + + /** + *+ * TODO: comment + *
+ * + */ + private void removePermutationsOfShorterTasks() { + // now iterate the sorted list and for each task remove all other tasks that are shorter + // (i.e. come later in the sorted list) and that represent a subpart of the task + for (int i = 0; i < foundTasks.size(); i++) { + for (int j = i + 1; j < foundTasks.size();) { + if (foundTasks.get(j).size() < foundTasks.get(i).size()) { + // found a task that is a potential subtask. Check for this and remove the + // subtask if needed + List+ * TODO comment + *
+ * + * @author Patrick Harms + */ + private class Tasks implements Iterable+ * TODO: comment + *
+ * + * @param occurrenceCount + * @param sequences + */ + private Tasks(int occurrenceCount, List+ * TODO: comment + *
+ * + * @return + */ + private int getOccurrenceCount() { + return occurrenceCount; + } + + /** + *+ * TODO: comment + *
+ * + * @return + */ + private int size() { + return this.sequences.size(); + } + + /** + * + */ + + /* (non-Javadoc) + * @see java.lang.Iterable#iterator() + */ + @Override + public Iterator+ * the task tree node factory to be used for creating substructures for the temporal + * relationships identified during rule + *
+ */ + private ITaskTreeNodeFactory taskTreeNodeFactory; + /** + *+ * the task tree builder to be used for creating substructures for the temporal relationships + * identified during rule application + *
+ */ + private ITaskTreeBuilder taskTreeBuilder; + + /** + *+ * the GUI element filter to be applied or null if none is specified. + *
+ */ + private List+ * instantiates the rule with a task tree node factory and builder to be used during rule + * application but without a GUI element filter + *
+ * + * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures + * for the temporal relationships identified during rule + * application + * @param taskTreeBuilder the task tree builder to be used for creating substructures for + * the temporal relationships identified during rule application + */ + SequenceOnGuiElementDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this(null, taskTreeNodeFactory, taskTreeBuilder); + } + + /** + *+ * instantiates the rule with a GUI element filter. Only those types given in the filter will + * be considered during the rule application. For all other types, no subsequences will be + * created. + *
+ * + * @param guiElementFilter the GUI element filter to be applied + * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures + * for the temporal relationships identified during rule + * application + * @param taskTreeBuilder the task tree builder to be used for creating substructures for + * the temporal relationships identified during rule application + */ + SequenceOnGuiElementDetectionRule(List+ * generates subsequences for all groups of children of the provided parent, that operate + * in different GUI elements at the provided hierarchy level. It will not generate a sub + * sequence for the last elements, if the rule application shall not finalize. + *
+ * + * @param parent the parent node of which the children shall be grouped + * @param hierarchies the GUI hierarchies for the children of the parent + * @param hierarchyLevel the current hierarchy level to be considered + * @param maxHierarchyDepth the maximum hierarchy depth that may apply in this application + * @param finalize true, if the application shall be finalized, false else + * @param result the result of the rule application to add newly created parent + * nodes to + * + * @return RULE_APPLICATION_FINISHED, if at least one subsequence was generated, + * RULE_APPLICATION_FEASIBLE, if the application shall not be finalized but some + * children could be condensed if further data was available, and RULE_NOT_APPLIED, + * if no subsequence was created and none is can be created, because no further + * data is expected + */ + private RuleApplicationStatus generateSubSequences(ITaskTreeNode parent, + List+ * condenses a specified group of children on the provided parent to a subsequences and + * calls {@link #generateSubSequences(ITaskTreeNode, List, int, boolean, ITaskTreeBuilder, ITaskTreeNodeFactory, RuleApplicationResult)} + * for the newly created subsequence. The method does not condense subgroups consisting of + * only one child which is already a sequence. + *
+ * + * @param parent the parent task of which children shall be condensed + * @param hierarchies the GUI element hierarchies of the children of the parent + * @param hierarchyLevel the currently considered GUI element hierarchy level + * @param startIndex the index of the first child belonging to the subgroup + * @param endIndex the index of the last child belonging to the subgroup + * @param result the result of the rule application to add newly created parent nodes to + * + * @return RULE_APPLICATION_FINISHED, if at the subsequence was generated and RULE_NOT_APPLIED, + * if no subsequence was created, because only one child belonged to the group which + * was already a sequence + */ + private RuleApplicationStatus condenseSequence(ITaskTreeNode parent, + List+ * return a common denominator for the provided list of GUI elements, i.e. a GUI element, that + * is part of the parent GUI hiearchy of all GUI elements in the list. If there is no common + * denominator, the method returns null. + *
+ */ + private IGUIElement getCommonDenominator(List+ * returns the GUI element on which all interactions of the provided task takes place. If + * the task is a simple event task its target is returned. If the task is a parent task + * of several children, the common denominator of the GUI elements of all its children is + * returned. The method returns null, if there is no common GUI element for all events + * represented by the provided task. + *
+ */ + private IGUIElement getGuiElement(ITaskTreeNode node) { + if (node != null) { + List+ * recursive method calling itself to determine all terminal GUI elements of the provided + * task. The terminal GUI elements are stored in the provided list. + *
+ */ + private void getTerminalGuiElements(ITaskTreeNode node, List+ * returns a list of GUI elements that represents the whole GUI element hierarchy of the + * provided GUI element. The method considers the GUI element filter applied by this rule. + *
+ */ + private List+ * returns for a given GUI element the next GUI element in the upper GUI element hierarchy + * that matches the GUI element filter of the rule. If the provided GUI element already + * matches the filter, it is returned directly. + *
+ */ + private IGUIElement searchHierarchyForGuiElementWithConsideredType(IGUIElement guiElement) { + IGUIElement returnValue = guiElement; + + while ((returnValue != null) && !guiElementMatchesConsideredTypes(returnValue)) { + returnValue = returnValue.getParent(); + } + + return returnValue; + } + + /** + *+ * checks if the provided GUI element matches the GUI element filter applied by the rule. + *
+ */ + private boolean guiElementMatchesConsideredTypes(IGUIElement guiElement) { + if (guiElementFilter == null) { + return true; + } + else { + for (Class clazz : guiElementFilter) { + if (clazz.isInstance(guiElement)) { + return true; + } + } + + return false; + } + } + +} Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceOnSameTargetDetectionRule.java =================================================================== --- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceOnSameTargetDetectionRule.java (revision 1127) +++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceOnSameTargetDetectionRule.java (revision 1127) @@ -0,0 +1,204 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.temporalrelation; + +import java.util.List; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; + +/** + * This rule subdivides long sequences into subsequences of tasks on the same event target. + * Event targets are compared using the equals method. A more complex GUI model is ignored. + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +class SequenceOnSameTargetDetectionRule implements TemporalRelationshipRule { + + /** + *+ * the task tree node factory to be used for creating substructures for the temporal + * relationships identified during rule + *
+ */ + private ITaskTreeNodeFactory taskTreeNodeFactory; + /** + *+ * the task tree builder to be used for creating substructures for the temporal relationships + * identified during rule application + *
+ */ + private ITaskTreeBuilder taskTreeBuilder; + + /** + *+ * instantiates the rule with a task tree node factory and builder to be used during rule + * application. + *
+ * + * @param taskTreeNodeFactory the task tree node factory to be used for creating substructures + * for the temporal relationships identified during rule + * application + * @param taskTreeBuilder the task tree builder to be used for creating substructures for + * the temporal relationships identified during rule application + */ + SequenceOnSameTargetDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + } + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return "SequenceOnSameTargetDetectionRule"; + } + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * boolean) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { + if (!(parent instanceof ISequence)) { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + IEventTarget currentEventTarget = null; + int startingIndex = -1; + + int index = 0; + List+ * TODO comment + *
+ * + * @author Patrick Harms + */ +class SimpleIterationDetectionRule implements TemporalRelationshipRule { + + /** + *+ * the task tree node factory to be used for creating substructures for the temporal + * relationships identified during rule + *
+ */ + private ITaskTreeNodeFactory taskTreeNodeFactory; + /** + *+ * the task tree builder to be used for creating substructures for the temporal relationships + * identified during rule application + *
+ */ + private ITaskTreeBuilder taskTreeBuilder; + + /** + *+ * the node comparator used for comparing task tree nodes with each other + *
+ */ + private TaskTreeNodeComparator nodeComparator; + + /** + *+ * 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. + *
+ */ + SimpleIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager, + NodeEquality minimalNodeEquality, + ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + + this.nodeComparator = + new TaskTreeNodeComparator(nodeEqualityRuleManager, 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. + *
+ */ + SimpleIterationDetectionRule(TaskTreeNodeComparator nodeComparator, + ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder) + { + this.nodeComparator = nodeComparator; + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + } + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return "SimpleIterationDetectionRule"; + } + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, + * boolean) + */ + @Override + public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { + if (!(parent instanceof ISequence)) { + return null; + } + + if (!finalize) { + // this rule can only finalize whole trees + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + applyOn(parent, result); + + if (result.getNewlyCreatedParentNodes().size() > 0) { + result.setRuleApplicationStatus(RuleApplicationStatus.FINISHED); + } + + return result; + } + + /** + * + */ + private void applyOn(ITaskTreeNode node, RuleApplicationResult result) { + int iterationStartIndex = -1; + ITaskTreeNode iteratedChild = null; + + int index = 0; + List+ * TODO: comment + *
+ * + * @return + */ + StopWatch getStopWatch() { + return stopWatch; + } + + /** + *+ * TODO: comment + *
+ * + * @param node1 + * @param node2 + * @return + */ + boolean areLexicallyEqual(ITaskTreeNode symbol1, ITaskTreeNode symbol2) { + Boolean result; + + if (symbol1 != symbol2) { + long key = ((long) System.identityHashCode(symbol1)) << 32; + key += System.identityHashCode(symbol2); + + result = lexicalEqualityBuffer.get(key); + + if (result == null) { + result = lexicalComparer.compare(symbol1, symbol2); + lexicalEqualityBuffer.put(key, result); + } + } + else { + result = true; + } + + return result; + } + + /** + *+ * TODO: comment + *
+ * + * @return + */ + NodeEquality getConsideredNodeEquality() { + return minimalNodeEquality; + } + + /** + * + */ + private interface Comparer { + /** + * + */ + boolean compare(ITaskTreeNode node1, ITaskTreeNode node2); + } + + /** + * + */ + private class LexicalComparer implements Comparer { + + /** + * + */ + public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { + return nodeEqualityRuleManager.areLexicallyEqual(node1, node2); + } + } + + /** + * + */ + private class SyntacticalComparer implements Comparer { + + /** + * + */ + public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { + return nodeEqualityRuleManager.areSyntacticallyEqual(node1, node2); + } + } + + /** + * + */ + private class SemanticalComparer implements Comparer { + + /** + * + */ + public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { + return nodeEqualityRuleManager.areSemanticallyEqual(node1, node2); + } + } + + /** + * + */ + private class DefaultComparer implements Comparer { + + /** + * + */ + public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { + return nodeEqualityRuleManager.areAtLeastEqual(node1, node2, minimalNodeEquality); + } + } } Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeMerger.java =================================================================== --- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeMerger.java (revision 1127) +++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeMerger.java (revision 1127) @@ -0,0 +1,590 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.temporalrelation; + +import java.util.List; + +import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; +import difflib.ChangeDelta; +import difflib.Chunk; +import difflib.DeleteDelta; +import difflib.Delta; +import difflib.InsertDelta; +import difflib.Patch; +import difflib.myers.DiffNode; +import difflib.myers.MyersDiff; +import difflib.myers.PathNode; +import difflib.myers.Snake; + +/** + *+ * TODO comment + *
+ * + * @author Patrick Harms + */ +class TaskTreeNodeMerger { + + /** */ + private ITaskTreeNodeFactory taskTreeNodeFactory; + + /** */ + private ITaskTreeBuilder taskTreeBuilder; + + /** */ + private TaskTreeNodeComparator nodeComparator; + + /** + *+ * TODO: comment + *
+ * + * @param taskTreeNodeFactory the node factory to be used if nodes must be instantiated + * @param taskTreeBuilder the task tree builder to be used if nodes must be merged + * @param nodeEqualityRuleManager the node equality rule manager that may be needed for + * comparing nodes during merge + * @param consideredNodeEquality the node equality considered when comparing nodes to + * identify them as equal + */ + TaskTreeNodeMerger(ITaskTreeNodeFactory taskTreeNodeFactory, + ITaskTreeBuilder taskTreeBuilder, + TaskTreeNodeComparator nodeComparator) + { + super(); + this.taskTreeNodeFactory = taskTreeNodeFactory; + this.taskTreeBuilder = taskTreeBuilder; + this.nodeComparator = nodeComparator; + } + + /** + *+ * 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 #mergeTaskNodes(ITaskTreeNode, ITaskTreeNode)} 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 + */ + void mergeTaskNodes(List+ * this method merges two 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 + * + * @return the result of the merge + */ + ITaskTreeNode mergeTaskNodes(ITaskTreeNode node1, ITaskTreeNode node2) { + ITaskTreeNode mergeResult = null; + + // both are of same parent type + if ((node1 instanceof ISequence) && (node2 instanceof ISequence)) { + mergeResult = mergeSequences((ISequence) node1, (ISequence) node2); + } + else if ((node1 instanceof ISelection) && (node2 instanceof ISelection)) { + mergeResult = mergeSelections((ISelection) node1, (ISelection) node2); + } + else if ((node1 instanceof IIteration) && (node2 instanceof IIteration)) { + mergeResult = mergeIterations((IIteration) node1, (IIteration) node2); + } + else if ((node1 instanceof IOptional) && (node2 instanceof IOptional)) { + mergeResult = mergeOptionals((IOptional) node1, (IOptional) node2); + } + // one is an iteration + else if (node1 instanceof IIteration) { + mergeResult = mergeTaskNodes(((IIteration) node1).getChildren().get(0), node2); + + if (mergeResult != null) { + taskTreeBuilder.setChild((IIteration) node1, mergeResult); + mergeResult = node1; + } + } + else if (node2 instanceof IIteration) { + mergeResult = mergeTaskNodes(((IIteration) node2).getChildren().get(0), node1); + + if (mergeResult != null) { + taskTreeBuilder.setChild((IIteration) node2, mergeResult); + mergeResult = node2; + } + } + // one is an optional + else if (node1 instanceof IOptional) { + mergeResult = mergeTaskNodes(((IOptional) node1).getChildren().get(0), node2); + + if (mergeResult != null) { + taskTreeBuilder.setChild((IOptional) node1, mergeResult); + mergeResult = node1; + } + } + else if (node2 instanceof IOptional) { + mergeResult = mergeTaskNodes(((IOptional) node2).getChildren().get(0), node1); + + if (mergeResult != null) { + taskTreeBuilder.setChild((IOptional) node2, mergeResult); + mergeResult = node2; + } + } + // one is a selection + else if (node1 instanceof ISelection) { + ISelection selection2 = taskTreeNodeFactory.createNewSelection(); + taskTreeBuilder.addChild(selection2, node2); + mergeResult = mergeSelections((ISelection) node1, selection2); + } + else if (node2 instanceof ISelection) { + ISelection selection1 = taskTreeNodeFactory.createNewSelection(); + taskTreeBuilder.addChild(selection1, node1); + mergeResult = mergeSelections(selection1, (ISelection) node2); + } + // one is a sequence + else if (node1 instanceof ISequence) { + ISequence sequence2 = taskTreeNodeFactory.createNewSequence(); + taskTreeBuilder.addChild(sequence2, node2); + mergeResult = mergeSequences((ISequence) node1, sequence2); + } + else if (node2 instanceof ISequence) { + ISequence sequence1 = taskTreeNodeFactory.createNewSequence(); + taskTreeBuilder.addChild(sequence1, node1); + mergeResult = mergeSequences(sequence1, (ISequence) node2); + } + // both are event tasks + else { + // only drop nodes which are definitely lexically equal + if (nodeComparator.areLexicallyEqual(node1, node2)) { + mergeResult = node1; + } + } + + if (mergeResult == null) { + mergeResult = taskTreeNodeFactory.createNewSelection(); + taskTreeBuilder.setDescription(mergeResult, "variants of " + node1); + taskTreeBuilder.addChild((ISelection) mergeResult, node1); + taskTreeBuilder.addChild((ISelection) mergeResult, node2); + } + + return mergeResult; + } + + /** + *+ * merges equal sequences. This is done through performing a diff between the two sequences. + * For each identified difference appropriate substructures are created. For equal parts, + * the appropriate equal nodes are merged using + * {@link #mergeTaskNodes(ITaskTreeNode, ITaskTreeNode)} and the result is added to the + * overall merge result. + *
+ * + * @param sequence1 the first sequence to be merged + * @param sequence2 the second sequence to be merged + * + * @return the result of the merge or null if merging was not possible + */ + ITaskTreeNode mergeSequences(ISequence sequence1, ISequence sequence2) { + ITaskTreeNode mergeResult = taskTreeNodeFactory.createNewSequence(); + + List+ * merges equal selections. This is done by adding those children of the second selection to + * the first selection that can not be merged with any of the children of the first selection. + * If a merge is possible and this merge is not a simple selection of the merged children, + * then the merged child replaces the child of the first selection which was merged. + *
+ * + * @param selection1 the first selection to be merged + * @param selection2 the second selection to be merged + * + * @return the result of the merge which is never null + */ + ITaskTreeNode mergeSelections(ISelection selection1, ISelection selection2) { + ISelection mergeResult = selection1; + + ITaskTreeNode childToMerge = null; + ITaskTreeNode mergedChild = null; + + List+ * 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 iteration1 the first iteration to be merged + * @param iteration2 the second iteration to be merged + * + * @return the result of the merge or null if merging is not possible + */ + ITaskTreeNode mergeIterations(IIteration iteration1, IIteration iteration2) { + ITaskTreeNode mergedChild = mergeTaskNodes + (iteration1.getChildren().get(0), iteration2.getChildren().get(0)); + + IIteration mergeResult = null; + + if (mergedChild != null) { + mergeResult = iteration1; + taskTreeBuilder.setChild(mergeResult, mergedChild); + } + + return mergeResult; + } + + /** + *+ * merges equal optionals. This is done through merging the children of both optionals. If + * this is possible, a resulting optional 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 optional1 the first optional to be merged + * @param optional2 the second optional to be merged + * + * @return the result of the merge or null if merging is not possible + */ + ITaskTreeNode mergeOptionals(IOptional optional1, IOptional optional2) { + ITaskTreeNode mergedChild = mergeTaskNodes + (optional1.getChildren().get(0), optional2.getChildren().get(0)); + + IOptional mergeResult = null; + + if (mergedChild != null) { + mergeResult = optional1; + taskTreeBuilder.setChild(mergeResult, mergedChild); + } + + return mergeResult; + } + + /** + *+ * determines a task tree node defined by the provided chunk. This is either a single node if + * the chunck denotes a single child, or it is a sequence of the denoted children. + *
+ */ + private ITaskTreeNode getSubTree(List