Changeset 1127 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe

Timestamp:

03/18/13 11:54:15 (12 years ago)

Author:

pharms

Message:

• complete refactoring of task detection
• many performance improvements in task detection
• improved merging of sequences using Myers diff algorithm

Location:

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation

Files:

• IterationOfSubtreesDetectionRule.java (moved) (moved from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java) (19 diffs)
• RuleApplicationResult.java (modified) (1 diff)
• RuleApplicationStatus.java (modified) (1 diff)
• RuleUtils.java (modified) (2 diffs)
• SequenceDependingOnEventTypeDetectionRule.java (moved) (moved from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java) (11 diffs)
• SequenceForTaskDetectionRule.java (moved) (moved from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultTaskSequenceDetectionRule.java) (32 diffs)
• SequenceOnGuiElementDetectionRule.java (moved) (moved from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java) (12 diffs)
• SequenceOnSameTargetDetectionRule.java (moved) (moved from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultEventTargetSequenceDetectionRule.java) (8 diffs)
• SimpleIterationDetectionRule.java (added)
• TaskTreeNodeComparator.java (modified) (4 diffs)
• TaskTreeNodeMerger.java (added)
• TemporalRelationshipRuleManager.java (modified) (6 diffs)
• TrackBarSelectionDetectionRule.java (modified) (6 diffs)
• TreeScopeWrapperRule.java (modified) (3 diffs)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/IterationOfSubtreesDetectionRule.java

@@ -75 +75 @@
  * @author Patrick Harms
  */
-class DefaultIterationDetectionRule implements TemporalRelationshipRule {
+class IterationOfSubtreesDetectionRule implements TemporalRelationshipRule {
 
     /**
@@ -101 +101 @@
     /**
      * <p>
-     * the node equality manager needed for comparing task tree nodes with each other
-     * </p>
-     */
-    private NodeEqualityRuleManager nodeEqualityRuleManager;
-
-    /**
-     * <p>
-     * the minimal node equality two identified sublists need to have to consider them as equal
-     * and to create an iteration for
-     * </p>
-     */
-    private NodeEquality minimalNodeEquality;
+     * the node comparator used for comparing task tree nodes with each other
+     * </p>
+     */
+    private TaskTreeNodeComparator nodeComparator;
 
     /**
@@ -120 +112 @@
      * </p>
      */
-    DefaultIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager,
-                                  NodeEquality            minimalNodeEquality,
-                                  ITaskTreeNodeFactory    taskTreeNodeFactory,
-                                  ITaskTreeBuilder        taskTreeBuilder)
+    IterationOfSubtreesDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager,
+                                     NodeEquality            minimalNodeEquality,
+                                     ITaskTreeNodeFactory    taskTreeNodeFactory,
+                                     ITaskTreeBuilder        taskTreeBuilder)
     {
-        this.nodeEqualityRuleManager = nodeEqualityRuleManager;
-        this.minimalNodeEquality = minimalNodeEquality;
         this.taskTreeNodeFactory = taskTreeNodeFactory;
         this.taskTreeBuilder = taskTreeBuilder;
+        
+        this.nodeComparator =
+            new TaskTreeNodeComparator(nodeEqualityRuleManager, minimalNodeEquality);
+    }
+
+    /**
+     * <p>
+     * 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.
+     * </p>
+     */
+    IterationOfSubtreesDetectionRule(TaskTreeNodeComparator nodeComparator,
+                                     ITaskTreeNodeFactory   taskTreeNodeFactory,
+                                     ITaskTreeBuilder       taskTreeBuilder)
+    {
+        this.nodeComparator = nodeComparator;
+        this.taskTreeNodeFactory = taskTreeNodeFactory;
+        this.taskTreeBuilder = taskTreeBuilder;
     }
 
@@ -136 +144 @@
     @Override
     public String toString() {
-        return "DefaultIterationDetectionRule";
+        return "IterationOfSubtreesDetectionRule";
     }
 
@@ -154 +162 @@
             // the rule is always feasible as iterations may occur at any time
             RuleApplicationResult result = new RuleApplicationResult();
-            result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+            result.setRuleApplicationStatus(RuleApplicationStatus.FEASIBLE);
             return result;
         }
 
+        List<ITaskTreeNode> children = parent.getChildren();
+        
         // parent must already have at least 2 children
-        if ((parent.getChildren() == null) || (parent.getChildren().size() < 2)) {
+        if ((children == null) || (children.size() < 2)) {
             return null;
         }
         
-        
-        SubSequences subSequences = getEqualSubsequences(parent);
+        SubSequences subSequences = getEqualSubsequences(children);
 
         if (subSequences != null) {
             RuleApplicationResult result = new RuleApplicationResult();
 
-            mergeEqualNodes(subSequences.equalVariants);
+            // merge the identified variants, but preserve the differences in form of selections
+            // by using lexical equality for merge comparisons
+            TaskTreeNodeMerger merger = new TaskTreeNodeMerger
+                (taskTreeNodeFactory, taskTreeBuilder, nodeComparator);
+
+            merger.mergeTaskNodes(subSequences.equalVariants);
+            
             IIteration newIteration =
                 createIterationBasedOnIdentifiedVariants(subSequences, result);
@@ -183 +198 @@
             taskTreeBuilder.addChild((ISequence) parent, subSequences.start, newIteration);
 
-            result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+            result.setRuleApplicationStatus(RuleApplicationStatus.FINISHED);
             return result;
         }
@@ -193 +208 @@
      * <p>
      * 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
+     * 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
@@ -202 +217 @@
      * </p>
      * 
-     * @param parent      the parent node in which iterations of children shall be found
+     * @param nodes the list of nodes in which iterations shall be found
      * 
      * @return the iterated subsequences identified in a specific part (contains the equal
@@ -208 +223 @@
      *         subpart in which the sequences were found) 
      */
-    private SubSequences getEqualSubsequences(ITaskTreeNode parent) {
+    private SubSequences getEqualSubsequences(List<ITaskTreeNode> nodes) {
         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 end = nodes.size(); end > 0; end--) {
             for (int start = 0; start < end; start++) {
-                boolean useEqualSublistLengths = equalSublistLengthsCanBeUsed(parent, start, end);
+                boolean useEqualSublistLengths = equalSublistLengthsCanBeUsed(nodes, start, end);
 
                 subSequences = new SubSequences();
@@ -221 +236 @@
 
                 boolean foundFurtherVariants = findFurtherVariants
-                    (subSequences, parent, start, end, useEqualSublistLengths);
+                    (subSequences, nodes, start, end, useEqualSublistLengths);
 
                 if (foundFurtherVariants) {
@@ -239 +254 @@
      * 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.
+     * 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 children of the parent in which an iteration shall be searched for are event
-     * tasks.
+     * check if all nodes in the list in which an iteration shall be searched for are event tasks.
      * </p>
      *
-     * @param parent the parent node to search for iterations of its children
+     * @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
@@ -252 +266 @@
      * @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);
+    private boolean equalSublistLengthsCanBeUsed(List<ITaskTreeNode> nodes, int start, int end) {
+        boolean equalLengthsCanBeUsed =
+            nodeComparator.getConsideredNodeEquality().isAtLeast(NodeEquality.LEXICALLY_EQUAL);
         
         if (equalLengthsCanBeUsed) {
             for (int i = start; i < end; i++) {
-                if (!(parent.getChildren().get(i) instanceof IEventTask)) {
+                if (!(nodes.get(i) instanceof IEventTask)) {
                     equalLengthsCanBeUsed = false;
                     break;
@@ -269 +284 @@
     /**
      * <p>
-     * 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.
+     * 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.
      * </p>
      * 
      * @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 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 children
-     *                               in which iterations are searched for
+     * @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
@@ -288 +303 @@
      * @return true if a further equal variant was found, false else
      */
-    private boolean findFurtherVariants(SubSequences         subSequences,
-                                        ITaskTreeNode        parent,
-                                        int                  start,
-                                        int                  end,
-                                        boolean              useEqualSublistLengths)
+    private boolean findFurtherVariants(SubSequences        subSequences,
+                                        List<ITaskTreeNode> nodes,
+                                        int                 start,
+                                        int                 end,
+                                        boolean             useEqualSublistLengths)
     {
         boolean foundFurtherVariants = (start == end) && (subSequences.equalVariants.size() > 1);
@@ -312 +327 @@
             
             for (int j = start; j < start + childCount; j++) {
-                taskTreeBuilder.addChild(furtherVariant, parent.getChildren().get(j));
+                taskTreeBuilder.addChild(furtherVariant, nodes.get(j));
             }
             
@@ -318 +333 @@
             
             for (ITaskTreeNode equalVariant : subSequences.equalVariants) {
-                NodeEquality nodeEquality =
-                    nodeEqualityRuleManager.applyRules(equalVariant, furtherVariant);
-                
-                if (!nodeEquality.isAtLeast(minimalNodeEquality)) {
+                if (!nodeComparator.equals(equalVariant, furtherVariant)) {
                     allVariantsEqual = false;
                     break;
@@ -335 +347 @@
                 
                 foundFurtherVariants = findFurtherVariants
-                    (subSequences, parent, start + childCount, end, useEqualSublistLengths);
+                    (subSequences, nodes, start + childCount, end, useEqualSublistLengths);
 
                 if (foundFurtherVariants) {
@@ -348 +360 @@
         
         return foundFurtherVariants;
-    }
-
-    /**
-     * <p>
-     * 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. 
-     * </p>
-     *
-     * @param nodes       the list of nodes to be merged
-     */
-    private void mergeEqualNodes(List<ITaskTreeNode> nodes) {
-        int index1 = 0;
-        int index2 = 0;
-        ITaskTreeNode variant1;
-        ITaskTreeNode variant2;
-        
-        while (index1 < nodes.size()) {
-            variant1 = nodes.get(index1);
-            index2 = index1 + 1;
-            
-            while (index2 < nodes.size()) {
-                variant2 = nodes.get(index2);
-                ITaskTreeNode mergedChild = mergeEqualTasks(variant1, variant2);
-                
-                if (mergedChild != null) {
-                    // if we merged something start from the beginning to perform the next merge
-                    nodes.remove(index2);
-                    nodes.remove(index1);
-                    nodes.add(index1, mergedChild);
-                    index1 = -1;
-                    break;
-                }
-                else {
-                    index2++;
-                }
-            }
-            
-            index1++;
-        }
-    }
-
-    /**
-     * <p>
-     * 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.
-     * </p>
-     *
-     * @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;
-    }
-
-    /**
-     * <p>
-     * 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.
-     * </p>
-     *
-     * @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;
-    }
-
-    /**
-     * <p>
-     * 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.
-     * </p>
-     *
-     * @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;
-    }
-
-    /**
-     * <p>
-     * 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.
-     * </p>
-     *
-     * @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;
     }
 
@@ -691 +475 @@
         List<ITaskTreeNode> parentNodes = new ArrayList<ITaskTreeNode>();
         
-        if (subtree.getChildren().size() > 0) {
+        List<ITaskTreeNode> children = subtree.getChildren();
+        
+        if (children.size() > 0) {
             parentNodes.add(subtree);
             
-            for (ITaskTreeNode child : subtree.getChildren()) {
+            for (ITaskTreeNode child : children) {
                 parentNodes.addAll(getParentNodes(child));
             }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationResult.java

@@ -33 +33 @@
 
     /** */
-    private RuleApplicationStatus status = RuleApplicationStatus.RULE_NOT_APPLIED;
+    private RuleApplicationStatus status = RuleApplicationStatus.NOT_APPLIED;
 
     /** */

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationStatus.java

@@ -24 +24 @@
  */
 enum RuleApplicationStatus {
-    RULE_APPLICATION_FINISHED,
-    RULE_APPLICATION_FEASIBLE,
-    RULE_NOT_APPLIED;
+    FINISHED,
+    FEASIBLE,
+    NOT_APPLIED;
 }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleUtils.java

@@ -35 +35 @@
      * 
      */
+    static ISequence getSubSequenceInRange(ITaskTreeNode         parent,
+                                           int                   startIndex,
+                                           int                   endIndex,
+                                           String                description,
+                                           ITaskTreeNodeFactory  nodeFactory,
+                                           ITaskTreeBuilder      builder)
+    {
+        ISequence sequence = nodeFactory.createNewSequence();
+        if (description != null) {
+            builder.setDescription(sequence, description);
+        }
+
+        for (int i = startIndex; i <= endIndex; i++) {
+            builder.addChild(sequence, parent.getChildren().get(i));
+        }
+
+        return sequence;
+    }
+
+    /**
+     * 
+     */
     static ISequence createNewSubSequenceInRange(ITaskTreeNode         parent,
                                                  int                   startIndex,
@@ -60 +82 @@
      *
      */
-    public static synchronized String getNewId() {
+    static synchronized String getNewId() {
         return Integer.toString(idCounter++);
     }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceDependingOnEventTypeDetectionRule.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
 
+import java.util.List;
 import java.util.Stack;
 
@@ -34 +35 @@
  * @author 2012, last modified by $Author: patrick$
  */
-class DefaultGuiEventSequenceDetectionRule implements TemporalRelationshipRule {
+class SequenceDependingOnEventTypeDetectionRule implements TemporalRelationshipRule {
 
     /**
@@ -63 +64 @@
      *                            the temporal relationships identified during rule application
      */
-    DefaultGuiEventSequenceDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory,
-                                         ITaskTreeBuilder     taskTreeBuilder)
+    SequenceDependingOnEventTypeDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory,
+                                              ITaskTreeBuilder     taskTreeBuilder)
     {
         this.taskTreeNodeFactory = taskTreeNodeFactory;
@@ -75 +76 @@
     @Override
     public String toString() {
-        return "DefaultGuiEventSequenceDetectionRule";
+        return "SequenceDependingOnEventTypeDetectionRule";
     }
 
@@ -93 +94 @@
         Stack<Integer> sequenceStartingIndex = new Stack<Integer>();
 
+        List<ITaskTreeNode> children = parent.getChildren();
+        
         int index = 0;
-        while (index < parent.getChildren().size()) {
-            ITaskTreeNode child = parent.getChildren().get(index);
+        while (index < children.size()) {
+            ITaskTreeNode child = children.get(index);
 
             if ((child instanceof IEventTask) &&
@@ -104 +107 @@
                 if (eventType.finishesLogicalSequence() && (sequenceStartingIndex.size() > 0)) {
                     index = handleLogicalSequence(sequenceStartingIndex, index, parent, result);
+                    // the parents child list will have changed, retrieve it again
+                    children = parent.getChildren();
                 }
 
@@ -116 +121 @@
         if (sequenceStartingIndex.size() > 0) {
             if (!finalize) {
-                result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+                result.setRuleApplicationStatus(RuleApplicationStatus.FEASIBLE);
             }
             else {
-                ITaskTreeNode lastChild = parent.getChildren().get(parent.getChildren().size() - 1);
+                ITaskTreeNode lastChild = children.get(children.size() - 1);
                 
                 if (lastChild instanceof IEventTask) {
                     handleLogicalSequence
-                        (sequenceStartingIndex, parent.getChildren().size() - 1, parent, result);
+                        (sequenceStartingIndex, children.size() - 1, parent, result);
                 }
             }
@@ -143 +148 @@
     {
         int newIndex = index;
+        
+        List<ITaskTreeNode> children = parent.getChildren();
+        
         IInteraction eventType =
-            (IInteraction) ((IEventTask) parent.getChildren().get(index)).getEventType();
+            (IInteraction) ((IEventTask) children.get(index)).getEventType();
 
         // There are several situations in which this implementation may cause infinite
@@ -163 +171 @@
         
         boolean allChildrenBelongToSubSequence =
-            (sequenceStartingIndex.peek() == 0) && (index == (parent.getChildren().size() - 1));
+            (sequenceStartingIndex.peek() == 0) && (index == (children.size() - 1));
         
         boolean atLeastOneChildToCondense = index - sequenceStartingIndex.peek() > 0;
@@ -172 +180 @@
 
             for (int j = startIndex; j < index; j++) {
-                taskTreeBuilder.addChild(sequence, parent.getChildren().get(startIndex));
+                taskTreeBuilder.addChild(sequence, children.get(startIndex));
                 taskTreeBuilder.removeChild((ISequence) parent, startIndex);
             }
 
             if (!eventType.startsLogicalSequence()) {
-                taskTreeBuilder.addChild(sequence, parent.getChildren().get(startIndex));
+                taskTreeBuilder.addChild(sequence, children.get(startIndex));
                 taskTreeBuilder.removeChild((ISequence) parent, startIndex);
                 newIndex = startIndex;
@@ -191 +199 @@
             taskTreeBuilder.setDescription(sequence, "logical sequence started by the first event");
                 
-            result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+            result.setRuleApplicationStatus(RuleApplicationStatus.FINISHED);
         }
         

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRule.java

@@ -21 +21 @@
 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+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 de.ugoe.cs.autoquest.usageprofiles.SymbolComparator;
 import de.ugoe.cs.autoquest.usageprofiles.Trie;
 import de.ugoe.cs.autoquest.usageprofiles.TrieProcessor;
+import de.ugoe.cs.util.console.Console;
 
 /**
@@ -36 +38 @@
  * @author Patrick Harms
  */
-class DefaultTaskSequenceDetectionRule implements TemporalRelationshipRule {
+class SequenceForTaskDetectionRule implements TemporalRelationshipRule {
     
     /**
@@ -58 +60 @@
      * </p>
      */
-    private SymbolComparator<ITaskTreeNode> nodeComparator;
+    private TaskTreeNodeComparator nodeComparator;
 
     /**
@@ -66 +68 @@
      * </p>
      */
-    DefaultTaskSequenceDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager,
-                                     NodeEquality            minimalNodeEquality,
-                                     ITaskTreeNodeFactory    taskTreeNodeFactory,
-                                     ITaskTreeBuilder        taskTreeBuilder)
+    SequenceForTaskDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager,
+                                 NodeEquality            minimalNodeEquality,
+                                 ITaskTreeNodeFactory    taskTreeNodeFactory,
+                                 ITaskTreeBuilder        taskTreeBuilder)
     {
         this.taskTreeNodeFactory = taskTreeNodeFactory;
@@ -83 +85 @@
     @Override
     public String toString() {
-        return "DefaultTaskSequenceDetectionRule";
+        return "SequenceForTaskDetectionRule";
     }
 
@@ -101 +103 @@
             // the rule is always feasible as tasks may occur at any time
             RuleApplicationResult result = new RuleApplicationResult();
-            result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+            result.setRuleApplicationStatus(RuleApplicationStatus.FEASIBLE);
             return result;
         }
 
-        RuleApplicationData<ITaskTreeNode> appData = new RuleApplicationData<ITaskTreeNode>(parent);
-        
-        appData.getStopWatch().start("whole rule application");
-        
+        List<ITaskTreeNode> children = parent.getChildren();
+        List<ISequence> sessions = new LinkedList<ISequence>();
+        
+        for (ITaskTreeNode child : children) {
+            if (child instanceof ISequence) {
+                sessions.add((ISequence) child);
+            }
+            else {
+                Console.println("provided parent is no parent of sessions");
+                return null;
+            }
+        }
+        
+        RuleApplicationData appData = new RuleApplicationData(sessions);
+
+        boolean finished = false;
+        
+        // this is the real rule application. Loop while something is replaced.
         do {
-            getSequencesOccuringMostOften(appData);
-            
-            if ((appData.getLastFoundSequences().size() > 0) &&
-                (appData.getLastFoundSequences().getOccurrenceCount() > 1))
-            {
-                System.out.println("found " + appData.getLastFoundSequences().size() +
-                                   " tasks occurring " +
-                                   appData.getLastFoundSequences().getOccurrenceCount() + " times");
-
-                for (List<ITaskTreeNode> task : appData.getLastFoundSequences()) {
-                    // only tasks occurring more often than once are of interest
-                    appData.stopWatch.start("creating task sequences");
-
-                    String taskId = "task " + RuleUtils.getNewId();
-                    System.out.println(taskId + ": " + task);
-                    
-                    appData.resetReplacementCounter();
-                    createSequenceForTaskOccurrences(taskId, task, parent, appData);
-                    
-                    if (appData.getReplacementCounter() <
-                        appData.getLastFoundSequences().getOccurrenceCount())
-                    {
-                        System.out.println(taskId + ": replaced task only " +
-                                           appData.getReplacementCounter() +
-                                           " times instead of expected " +
-                                           appData.getLastFoundSequences().getOccurrenceCount());
-                        
-                    }
-
-                    appData.stopWatch.stop("creating task sequences");
+            System.out.println();
+            
+            appData.getStopWatch().start("whole loop");
+            detectAndReplaceIterations(appData);
+            //mergeEqualTasks(appData);
+            appData.getStopWatch().start("task replacement");
+            detectAndReplaceTasks(appData);
+            appData.getStopWatch().stop("task replacement");
+            appData.getStopWatch().stop("whole loop");
+            
+            //((TaskTreeNodeComparator) nodeComparator).getStopWatch().dumpStatistics(System.out);
+            //((TaskTreeNodeComparator) nodeComparator).getStopWatch().reset();
+            
+            appData.getStopWatch().dumpStatistics(System.out);
+            appData.getStopWatch().reset();
+            
+            finished = (appData.getReplacementCounter() == 0);
+        }
+        while (!finished);
+        
+        System.out.println("created " + appData.getResult().getNewlyCreatedParentNodes().size() +
+                           " new parent nodes\n");
+        
+        if (appData.getResult().getNewlyCreatedParentNodes().size() > 0) {
+            appData.getResult().setRuleApplicationStatus(RuleApplicationStatus.FINISHED);
+        }
+        
+        return appData.getResult();
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param appData
+     */
+    private void detectAndReplaceIterations(RuleApplicationData appData) {
+        System.out.print("detecting iterations");
+        appData.getStopWatch().start("detecting iterations");
+        
+        List<ISequence> sessions = appData.getSessions();
+        int foundIterations = 0;
+        
+        for (ISequence session : sessions) {
+            foundIterations += detectAndReplaceIterations(session, appData);
+        }
+        
+        appData.getStopWatch().stop("detecting iterations");
+        System.out.println(" --> found " + foundIterations);
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @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++;
                 }
             }
-            
-        }
-        while (appData.getLastFoundSequences().getOccurrenceCount() > 2);
-        
-        appData.getStopWatch().stop("whole rule application");
-        appData.getStopWatch().dumpStatistics(System.out);
-        
-        if (appData.getResult().getNewlyCreatedParentNodes().size() > 0) {
-            appData.getResult().setRuleApplicationStatus
-                (RuleApplicationStatus.RULE_APPLICATION_FINISHED);
-        }
-        
-        System.out.println(appData.getResult().getNewlyCreatedParentNodes().size());
-        
-        for (ITaskTreeNode node : appData.getResult().getNewlyCreatedParentNodes()) {
-            for (ITaskTreeNode child : node.getChildren()) {
-                System.out.println(child);
-            }
-            System.out.println();
-        }
-        
-        return appData.getResult();
+        }
+        
+        return count;
+    }
+
+//    /**
+//     * <p>
+//     * TODO: comment
+//     * </p>
+//     *
+//     * @param appData
+//     */
+//    private void mergeEqualTasks(RuleApplicationData appData) {
+//        System.out.println("merging equal tasks");
+//        appData.getStopWatch().start("merging equal tasks");
+//        
+//        int replacements = 0;
+//        List<ISequence> sessions = appData.getSessions();
+//        
+//        IdentityHashMap<ITaskTreeNode, ITaskTreeNode> replacedChildren =
+//            new IdentityHashMap<ITaskTreeNode, ITaskTreeNode>();
+//        
+//        for (int sessionIdx1 = 0; sessionIdx1 < sessions.size(); sessionIdx1++) {
+//            List<ITaskTreeNode> children1 = appData.getSessions().get(sessionIdx1).getChildren();
+//            for (int childIdx1 = 0; childIdx1 < children1.size(); childIdx1++) {
+//                // this is the child of which we search equal other children to merge and to
+//                // replace with one single unique node
+//                ITaskTreeNode child1 = children1.get(childIdx1);
+//                
+//                if (replacedChildren.containsKey(child1)) {
+//                    continue;
+//                }
+//                
+//                // now search for all other children that are equal. Also record the session they
+//                // belong to as well as the index in that session
+//                List<ITaskTreeNode> equalChildren = new LinkedList<ITaskTreeNode>();
+//                List<Integer> sessionIndexes = new LinkedList<Integer>();
+//                List<Integer> childIndexes = new LinkedList<Integer>();
+//
+//                // add all information about the current child
+//                equalChildren.add(child1);
+//                sessionIndexes.add(sessionIdx1);
+//                childIndexes.add(childIdx1);
+//                
+//                for (int sessionIdx2 = sessionIdx1; sessionIdx2 < sessions.size(); sessionIdx2++) {
+//                    List<ITaskTreeNode> children2 =
+//                          appData.getSessions().get(sessionIdx2).getChildren();
+//                    
+//                    int startIndex = (sessionIdx1 == sessionIdx2) ? childIdx1 + 1 : 0;
+//                    
+//                    for (int childIdx2 = startIndex; childIdx2 < children2.size(); childIdx2++) {
+//                        ITaskTreeNode child2 = children2.get(childIdx2);
+//                        
+//                        if ((child1 != child2) && (nodeComparator.equals(child1, child2))) {
+//                            // this is an equal child --> record its occurrence
+//                            equalChildren.add(child2);
+//                            sessionIndexes.add(sessionIdx2);
+//                            childIndexes.add(childIdx2);
+//                        }
+//                    }
+//                }
+//                
+//                // now merge the found children
+//                if (equalChildren.size() > 1) {
+//                    ITaskTreeNode replacement =
+//                        mergeVariantsOfTasks(child1.toString(), equalChildren);
+//
+//                    for (int i = 0; i < sessionIndexes.size(); i++) {
+//                        taskTreeBuilder.setChild(appData.getSessions().get(sessionIndexes.get(i)),
+//                                                 childIndexes.get(i), replacement);
+//                    
+//                        replacements++;
+//                    }
+//                    
+//                    // remember the replacement to prevent comparison of merged nodes
+//                    replacedChildren.put(replacement, replacement);
+//                    
+//                    System.out.println
+//                        ("replaced " + sessionIndexes.size() + " occurrences of " + child1);
+//                }
+//            }
+//        }
+//
+//        appData.getStopWatch().stop("merging equal tasks");
+//        
+//        System.out.println("replaced " + replacements + " equal tasks with unique replacements");
+//    }
+//
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @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");
     }
 
@@ -174 +320 @@
      * @return
      */
-    private void getSequencesOccuringMostOften(RuleApplicationData<ITaskTreeNode> appData) {
-        System.out.println("determining most prominent tasks with a maximum of " +
-                           (appData.getLastFoundSequences().getOccurrenceCount() - 1) +
-                           " occurrences");
-
-        Sequences<ITaskTreeNode> sequences;
+    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
@@ -188 +332 @@
             }
             
-            /*PathDumper dumper = new PathDumper();
-            trie.process(dumper);
-        
-            dumper.dump();*/
-        
-            appData.getStopWatch().start("determining tasks");
-
-            MaxCountAndLongestSequenceFinder finder = new MaxCountAndLongestSequenceFinder
-                  (appData.getLastFoundSequences().getOccurrenceCount() - 1);
+            MaxCountAndLongestTasksFinder finder = new MaxCountAndLongestTasksFinder();
             appData.getLastTrie().process(finder);
         
-            sequences = finder.getFoundSequences();
+            tasks = finder.getFoundTasks();
             
             createNewTrie = false;
             
-            for (List<ITaskTreeNode> task : sequences) {
+            for (List<ITaskTreeNode> task : tasks) {
                 if (task.size() >= appData.getTrainedSequenceLength()) {
                     // Trie must be recreated with a longer sequence length to be sure that
@@ -212 +348 @@
                 }
             }
-            
-            appData.getStopWatch().stop("determining tasks");
         }
         while (createNewTrie);
         
-        appData.setLastFoundSequences(sequences);
+        appData.setLastFoundTasks(tasks);
+
+        System.out.println("found " + appData.getLastFoundTasks().size() + " tasks occurring " +
+                           appData.getLastFoundTasks().getOccurrenceCount() + " times");
     }
 
@@ -228 +365 @@
      * @return
      */
-    private void createNewTrie(RuleApplicationData<ITaskTreeNode> appData) {
+    private void createNewTrie(RuleApplicationData appData) {
         System.out.println("training trie with a maximum sequence length of " +
                            appData.getTrainedSequenceLength());
@@ -235 +372 @@
         appData.setLastTrie(new Trie<ITaskTreeNode>(nodeComparator));
     
-        trainTrie(appData.getTree(), appData);
+        List<ISequence> sessions = appData.getSessions();
+        
+        for (ISequence session : sessions) {
+            trainTrie(session, appData);
+        }
+        
         appData.getStopWatch().stop("training trie");
     }
@@ -247 +389 @@
      * @param parent
      */
-    private void trainTrie(ITaskTreeNode parent, RuleApplicationData<ITaskTreeNode> appData) {
-        // prevent training of already replaces sequences as those shall not be replaced anymore
-        if (!appData.getResult().getNewlyCreatedParentNodes().contains(parent)) {
-            List<ITaskTreeNode> children = parent.getChildren();
-        
-            if ((children != null) && (children.size() > 0)) {
+    private void trainTrie(ISequence session, RuleApplicationData appData) {
+        List<ITaskTreeNode> children = session.getChildren();
+        
+        if ((children != null) && (children.size() > 0)) {
+            appData.getLastTrie().train(children, appData.getTrainedSequenceLength());
+        }
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @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<ITaskTreeNode> task : appData.getLastFoundTasks()) {
+                String taskId = "task " + RuleUtils.getNewId();
+                System.out.println("replacing " + taskId + ": " + task);
+
+                appData.clearTaskOccurrences();
+                determineVariantsOfTaskOccurrences(task, appData.getSessions(), appData);
                 
-                /*System.out.println();
-                for (int i = 0; i < children.size(); i++) {
-                    System.out.println(children.get(i));
-                }*/
+                appData.getStopWatch().start("merging task nodes");
+                ITaskTreeNode taskReplacement = mergeVariantsOfTaskOccurrence(taskId, appData);
+                appData.getStopWatch().stop("merging task nodes");
+
+                appData.resetReplacementCounter();
+                replaceTaskOccurrences(task, taskReplacement, appData.getSessions(), appData);
+
+                if (appData.getReplacementCounter() > 0) {
+                    appData.getResult().addNewlyCreatedParentNode(taskReplacement);
+                }
+
+                if (appData.getReplacementCounter() <
+                    appData.getLastFoundTasks().getOccurrenceCount())
+                {
+                    System.out.println(taskId + ": replaced task only " +
+                                       appData.getReplacementCounter() +
+                                       " times instead of expected " +
+                                       appData.getLastFoundTasks().getOccurrenceCount());
+                }
+            }
+        }
+        
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param tree
+     */
+    private void determineVariantsOfTaskOccurrences(List<ITaskTreeNode> task,
+                                                    List<ISequence>     sessions,
+                                                    RuleApplicationData appData)
+    {
+        for (ISequence session : sessions) {
+            int index = -1;
                 
-                appData.getLastTrie().train(children, appData.getTrainedSequenceLength());
-            
-                for (ITaskTreeNode child : children) {
-                    trainTrie(child, appData);
+            List<ITaskTreeNode> children = session.getChildren();
+
+            do {
+                index = getSubListIndex(children, task, ++index);
+
+                if (index > -1) {
+                    ISequence taskOccurrence = RuleUtils.getSubSequenceInRange
+                            (session, index, index + task.size() - 1, null,
+                             taskTreeNodeFactory, taskTreeBuilder);
+
+                    appData.addTaskOccurrence(taskOccurrence);
+
+                    // let the index point to the last element the belongs the identified occurrence
+                    index += task.size() - 1;
                 }
             }
+            while (index > -1);
+        }
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param appData
+     * @return
+     */
+    private ITaskTreeNode mergeVariantsOfTaskOccurrence(String              taskId,
+                                                        RuleApplicationData appData)
+    {
+        return mergeVariantsOfTasks(taskId, appData.getTaskOccurrences());
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param appData
+     * @return
+     */
+    private ITaskTreeNode mergeVariantsOfTasks(String description, List<ITaskTreeNode> variants) {
+        // merge but preserve lexically distinct variants
+        TaskTreeNodeMerger merger = new TaskTreeNodeMerger
+            (taskTreeNodeFactory, taskTreeBuilder, nodeComparator);
+        
+        merger.mergeTaskNodes(variants);
+        
+        if (variants.size() == 1) {
+            ITaskTreeNode replacement = variants.get(0);
+            taskTreeBuilder.setDescription(replacement, description);
+            return replacement;
+        }
+        else {
+            ISelection selection = taskTreeNodeFactory.createNewSelection();
+            taskTreeBuilder.setDescription(selection, "variants of task " + description);
+            
+            for (ITaskTreeNode variant : variants) {
+                taskTreeBuilder.addChild(selection, variant);
+            }
+            
+            return selection;
         }
     }
@@ -279 +534 @@
      * @param result
      */
-    private void createSequenceForTaskOccurrences(String                             taskId,
-                                                  List<ITaskTreeNode>                task,
-                                                  ITaskTreeNode                      parent,
-                                                  RuleApplicationData<ITaskTreeNode> appData)
+    private void replaceTaskOccurrences(List<ITaskTreeNode> task,
+                                        ITaskTreeNode       replacement,
+                                        List<ISequence>     sessions,
+                                        RuleApplicationData appData)
     {
-        List<ITaskTreeNode> children = parent.getChildren();
-        
-        if ((children == null) || (children.size() == 0)) {
-            return;
-        }
-        
-        // first traverse the children
-        for (ITaskTreeNode child : children) {
-            createSequenceForTaskOccurrences(taskId, task, child, appData);
-        }
-        
         // now check the children themselves for an occurrence of the task
-        int index = -1;
-        
-        do {
-            index = getSubListIndex(children, task, ++index);
-            
-            if (index > -1) {
-                if (task.size() < children.size()) {
-                    ISequence sequence = RuleUtils.createNewSubSequenceInRange
-                        (parent, index, index + task.size() - 1, taskId,
-                         taskTreeNodeFactory, taskTreeBuilder);
-                    
-                    appData.getResult().addNewlyCreatedParentNode(sequence);
-                    appData.incrementReplacementCounter();
-                 
-                    children = parent.getChildren();
-                }
-                else {
-                    // the whole list of children is an occurrence of this task. Just set the
-                    // description of the parent and break up
-                    String description = parent.getDescription();
-                    
-                    if ((description != null) && (description.length() > 0)) {
-                        description += "; " + taskId;
+        for (int i = 0; i < sessions.size(); i++) {
+            ISequence session = sessions.get(i);
+            
+            int index = -1;
+        
+            List<ITaskTreeNode> children = session.getChildren();
+
+            do {
+                index = getSubListIndex(children, task, ++index);
+
+                if (index > -1) {
+                    if ((!(replacement instanceof ISequence)) ||
+                        (task.size() < children.size()))
+                    {
+                        for (int j = index; j < index + task.size(); j++) {
+                            taskTreeBuilder.removeChild(session, index);
+                        }
+
+                        taskTreeBuilder.addChild(session, index, replacement);
+                        appData.incrementReplacementCounter();
+
+                        children = session.getChildren();
                     }
                     else {
-                        description = taskId;
+                        // the whole list of children is an occurrence of this task. So ask the
+                        // caller of the method to replace the whole node
+                        sessions.set(i, (ISequence) replacement);
+                        appData.incrementReplacementCounter();
+                        break;
                     }
-                    
-                    taskTreeBuilder.setDescription(parent, description);
-                    break;
                 }
             }
-        }
-        while (index > -1);
+            while (index > -1);
+        }
     }
 
@@ -356 +600 @@
                     break;
                 }
-                else if (!nodeComparator.equals(subList.get(j), list.get(i + j))){
-                    throw new RuntimeException("comparator not commutative");
-                }
             }
             
@@ -377 +618 @@
      * @author Patrick Harms
      */
-    private class MaxCountAndLongestSequenceFinder implements TrieProcessor<ITaskTreeNode> {
-        
-        /**
-         * 
-         */
-        private int maxCount;
+    private class MaxCountAndLongestTasksFinder implements TrieProcessor<ITaskTreeNode> {
         
         /**
@@ -392 +628 @@
          * 
          */
-        private List<List<ITaskTreeNode>> foundSequences = new LinkedList<List<ITaskTreeNode>>();
+        private List<List<ITaskTreeNode>> foundTasks = new LinkedList<List<ITaskTreeNode>>();
 
         /**
@@ -401 +637 @@
          * @param maxCount
          */
-        public MaxCountAndLongestSequenceFinder(int maxCount) {
+        public MaxCountAndLongestTasksFinder() {
             super();
-            this.maxCount = maxCount;
             this.currentCount = 0;
         }
@@ -411 +646 @@
          */
         @Override
-        public TrieProcessor.Result process(List<ITaskTreeNode> sequence, int count) {
-            if (sequence.size() < 2) {
+        public TrieProcessor.Result process(List<ITaskTreeNode> task, int count) {
+            if (task.size() < 2) {
                 // ignore single nodes
                 return TrieProcessor.Result.CONTINUE;
@@ -422 +657 @@
             }
 
-            if (count > this.maxCount) {
-                // ignore sequences that occur too often
-                return TrieProcessor.Result.CONTINUE;
-            }
-            
             if (this.currentCount > count) {
                 // ignore this children of this node, as they may have only smaller counts than
-                // the already found sequences
+                // the already found tasks
                 return TrieProcessor.Result.SKIP_NODE;
             }
             
             if (this.currentCount < count) {
-                // the provided sequence occurs more often that all sequences found so far.
-                // clear all found sequences and use the new count as the one searched for
-                foundSequences.clear();
+                // the provided task occurs more often that all tasks found so far.
+                // clear all found tasks and use the new count as the one searched for
+                foundTasks.clear();
                 this.currentCount = count;
             }
             
             if (this.currentCount == count) {
-                // the sequence is of interest. Sort it into the other found sequences so that
+                // the task is of interest. Sort it into the other found tasks so that
                 // the longest come first
                 boolean added = false;
-                for (int i = 0; i < foundSequences.size(); i++) {
-                    if (foundSequences.get(i).size() < sequence.size()) {
+                for (int i = 0; i < foundTasks.size(); i++) {
+                    if (foundTasks.get(i).size() < task.size()) {
                         // defensive copy
-                        foundSequences.add(i, new LinkedList<ITaskTreeNode>(sequence)); // defensive copy
+                        foundTasks.add(i, new LinkedList<ITaskTreeNode>(task)); // defensive copy
                         added = true;
                         break;
@@ -454 +684 @@
                 
                 if (!added) {
-                    foundSequences.add(new LinkedList<ITaskTreeNode>(sequence)); // defensive copy
+                    foundTasks.add(new LinkedList<ITaskTreeNode>(task)); // defensive copy
                 }
             }
@@ -468 +698 @@
          * @return
          */
-        public Sequences<ITaskTreeNode> getFoundSequences() {
+        public Tasks getFoundTasks() {
             removePermutationsOfShorterTasks();
-            return new Sequences<ITaskTreeNode>(currentCount, foundSequences);
+            return new Tasks(currentCount, foundTasks);
         }
 
@@ -482 +712 @@
             // 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()) {
+            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<ITaskTreeNode> longTask = foundSequences.get(i);
-                        List<ITaskTreeNode> shortTask = foundSequences.get(j);
+                        List<ITaskTreeNode> longTask = foundTasks.get(i);
+                        List<ITaskTreeNode> shortTask = foundTasks.get(j);
                         
                         if (getSubListIndex(longTask, shortTask, 0) > -1) {
-                            foundSequences.remove(j);
+                            foundTasks.remove(j);
                         }
                         else {
@@ -509 +739 @@
      * 
      */
-    private class RuleApplicationData<T> {
-        
-        /**
-         * 
-         */
-        private T tree;
+    private class RuleApplicationData {
+        
+        /**
+         * 
+         */
+        private List<ISequence> sessions;
+        
+        /**
+         * 
+         */
+        private Trie<ITaskTreeNode> lastTrie;
+        
+        /**
+         * default and minimum trained sequence length is 3
+         */
+        private int trainedSequenceLength = 3;
+        
+        /**
+         * 
+         */
+        private Tasks lastFoundTasks = new Tasks(Integer.MAX_VALUE, null);
+        
+        /**
+         * 
+         */
+        private List<ITaskTreeNode> taskOccurrences = new LinkedList<ITaskTreeNode>();
+        
+        /**
+         * 
+         */
+        private int replacementCounter;
         
         /**
@@ -524 +779 @@
          * 
          */
-        private Sequences<T> lastFoundSequences = new Sequences<T>(Integer.MAX_VALUE, null);
-        
-        /**
-         * 
-         */
-        private Trie<T> lastTrie;
-        
-        /**
-         * default and minimum trained sequence length is 3
-         */
-        private int trainedSequenceLength = 3;
-        
-        /**
-         * 
-         */
-        private int replacementCounter;
-        
-        /**
-         * 
-         */
         private StopWatch stopWatch = new StopWatch();
         
@@ -549 +784 @@
          * 
          */
-        private RuleApplicationData(T tree) {
-            this.tree = tree;
-        }
-
-        /**
-         * @return the lastFoundSequences
-         */
-        private Sequences<T> getLastFoundSequences() {
-            return lastFoundSequences;
-        }
-
-        /**
-         * @param lastFoundSequences the lastFoundSequences to set
-         */
-        private void setLastFoundSequences(Sequences<T> lastFoundSequences) {
-            this.lastFoundSequences = lastFoundSequences;
+        private RuleApplicationData(List<ISequence> sessions) {
+            this.sessions = sessions;
+        }
+
+        /**
+         * @return the tree
+         */
+        private List<ISequence> getSessions() {
+            return sessions;
+        }
+
+        /**
+         * @param lastTrie the lastTrie to set
+         */
+        private void setLastTrie(Trie<ITaskTreeNode> lastTrie) {
+            this.lastTrie = lastTrie;
         }
 
@@ -570 +805 @@
          * @return the lastTrie
          */
-        private Trie<T> getLastTrie() {
+        private Trie<ITaskTreeNode> getLastTrie() {
             return lastTrie;
+        }
+
+        /**
+         * @param trainedSequenceLength the trainedSequenceLength to set
+         */
+        private void setTrainedSequenceLength(int trainedSequenceLength) {
+            this.trainedSequenceLength = trainedSequenceLength;
         }
 
@@ -582 +824 @@
 
         /**
-         * @param trainedSequenceLength the trainedSequenceLength to set
-         */
-        private void setTrainedSequenceLength(int trainedSequenceLength) {
-            this.trainedSequenceLength = trainedSequenceLength;
-        }
-
-        /**
-         * @param lastTrie the lastTrie to set
-         */
-        private void setLastTrie(Trie<T> lastTrie) {
-            this.lastTrie = lastTrie;
-        }
-
-        /**
-         * @return the tree
-         */
-        private T getTree() {
-            return tree;
-        }
-
+         * @param lastFoundSequences the lastFoundSequences to set
+         */
+        private void setLastFoundTasks(Tasks lastFoundSequences) {
+            this.lastFoundTasks = lastFoundSequences;
+        }
+
+        /**
+         * @return the lastFoundSequences
+         */
+        private Tasks getLastFoundTasks() {
+            return lastFoundTasks;
+        }
+
+        /**
+         * @return the taskOccurrences
+         */
+        private void clearTaskOccurrences() {
+            taskOccurrences.clear();
+        }
+
+        /**
+         * @return the taskOccurrences
+         */
+        private void addTaskOccurrence(ITaskTreeNode taskOccurrence) {
+            taskOccurrences.add(taskOccurrence);
+        }
+
+        /**
+         * @return the taskOccurrences
+         */
+        private List<ITaskTreeNode> getTaskOccurrences() {
+            return taskOccurrences;
+        }
+
+        /**
+         *
+         */
+        private void resetReplacementCounter() {
+            replacementCounter = 0;
+        }
+
+        /**
+         *
+         */
+        private void incrementReplacementCounter() {
+            replacementCounter++;
+        }
+
+        /**
+         *
+         */
+        private int getReplacementCounter() {
+            return replacementCounter;
+        }
+        
         /**
          * @return the result
@@ -616 +893 @@
         }
 
-        /**
-         *
-         */
-        private void resetReplacementCounter() {
-            replacementCounter = 0;
-        }
-
-        /**
-         *
-         */
-        private void incrementReplacementCounter() {
-            replacementCounter++;
-        }
-
-        /**
-         *
-         */
-        private int getReplacementCounter() {
-            return replacementCounter;
-        }
     }
     
@@ -646 +903 @@
      * @author Patrick Harms
      */
-    private class Sequences<T> implements Iterable<List<T>> {
+    private class Tasks implements Iterable<List<ITaskTreeNode>> {
         
         /**
@@ -656 +913 @@
          * 
          */
-        private List<List<T>> sequences;
+        private List<List<ITaskTreeNode>> sequences;
 
         /**
@@ -666 +923 @@
          * @param sequences
          */
-        private Sequences(int occurrenceCount, List<List<T>> sequences) {
+        private Tasks(int occurrenceCount, List<List<ITaskTreeNode>> sequences) {
             super();
             this.occurrenceCount = occurrenceCount;
@@ -702 +959 @@
          */
         @Override
-        public Iterator<List<T>> iterator() {
+        public Iterator<List<ITaskTreeNode>> iterator() {
             return this.sequences.iterator();
         }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceOnGuiElementDetectionRule.java

@@ -34 +34 @@
  * @author 2012, last modified by $Author: patrick$
  */
-class DefaultGuiElementSequenceDetectionRule implements TemporalRelationshipRule {
+class SequenceOnGuiElementDetectionRule implements TemporalRelationshipRule {
 
     /**
@@ -70 +70 @@
      *                            the temporal relationships identified during rule application
      */
-    DefaultGuiElementSequenceDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory,
-                                           ITaskTreeBuilder     taskTreeBuilder)
+    SequenceOnGuiElementDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory,
+                                      ITaskTreeBuilder     taskTreeBuilder)
     {
         this(null, taskTreeNodeFactory, taskTreeBuilder);
@@ -90 +90 @@
      *                            the temporal relationships identified during rule application
      */
-    DefaultGuiElementSequenceDetectionRule(List<Class<? extends IGUIElement>> guiElementFilter,
+    SequenceOnGuiElementDetectionRule(List<Class<? extends IGUIElement>> guiElementFilter,
                                            ITaskTreeNodeFactory taskTreeNodeFactory,
                                            ITaskTreeBuilder     taskTreeBuilder)
@@ -104 +104 @@
     @Override
     public String toString() {
-        return "DefaultGuiElementSequenceDetectionRule";
+        return "SequenceOnGuiElementDetectionRule";
     }
 
@@ -154 +154 @@
         
         if (status == null) {
-            status = RuleApplicationStatus.RULE_NOT_APPLIED;
+            status = RuleApplicationStatus.NOT_APPLIED;
         }
             
@@ -193 +193 @@
         int startingIndex = -1;
         
-        RuleApplicationStatus status = RuleApplicationStatus.RULE_NOT_APPLIED;
+        RuleApplicationStatus status = RuleApplicationStatus.NOT_APPLIED;
         boolean subsequenceHasStarted = false;
         boolean exceedingGuiHierarchyDepth = false;
@@ -202 +202 @@
 
         int index = 0;
-        while (index < parent.getChildren().size()) {
+        List<ITaskTreeNode> children = parent.getChildren();
+        
+        while (index < children.size()) {
             hierarchy = hierarchies.get(index);
 
@@ -220 +222 @@
                 status = condenseSequence
                     (parent, hierarchies, hierarchyLevel, startingIndex, index - 1, result);
+                
+                // children may have changed, retrieve them again.
+                children = parent.getChildren();
 
                 if (status != null) {
@@ -244 +249 @@
                 status = condenseSequence
                     (parent, hierarchies, hierarchyLevel, startingIndex,
-                     parent.getChildren().size() - 1, result);
-            }
-            else if (status != RuleApplicationStatus.RULE_APPLICATION_FINISHED) {
-                status = RuleApplicationStatus.RULE_NOT_APPLIED;
+                     children.size() - 1, result);
+            }
+            else if (status != RuleApplicationStatus.FINISHED) {
+                status = RuleApplicationStatus.NOT_APPLIED;
             }
         }
         else {
-            if ((currentParent != null) &&
-                (status != RuleApplicationStatus.RULE_APPLICATION_FINISHED))
-            {
-                status = RuleApplicationStatus.RULE_APPLICATION_FEASIBLE;
+            if ((currentParent != null) && (status != RuleApplicationStatus.FINISHED)) {
+                status = RuleApplicationStatus.FEASIBLE;
             }
         }
@@ -288 +291 @@
     {
         boolean onlyASingleChildToReduce = (endIndex - startIndex) == 0;
+        
+        List<ITaskTreeNode> children = parent.getChildren();
+        
         boolean singleChildIsSequence = onlyASingleChildToReduce &&
-            parent.getChildren().get(startIndex) instanceof ISequence;
+            children.get(startIndex) instanceof ISequence;
 
         if (!onlyASingleChildToReduce || !singleChildIsSequence) {
@@ -302 +308 @@
 
             for (int i = startIndex; i <= endIndex; i++) {
-                taskTreeBuilder.addChild(sequence, parent.getChildren().get(startIndex));
+                taskTreeBuilder.addChild(sequence, children.get(startIndex));
                 taskTreeBuilder.removeChild((ISequence) parent, startIndex);
                 
@@ -316 +322 @@
             result.addNewlyCreatedParentNode(sequence);
 
-            return RuleApplicationStatus.RULE_APPLICATION_FINISHED;
+            return RuleApplicationStatus.FINISHED;
         }
         else {

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceOnSameTargetDetectionRule.java

@@ -15 +15 @@
 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;
@@ -29 +31 @@
  * @author 2012, last modified by $Author: patrick$
  */
-class DefaultEventTargetSequenceDetectionRule implements TemporalRelationshipRule {
+class SequenceOnSameTargetDetectionRule implements TemporalRelationshipRule {
 
     /**
@@ -58 +60 @@
      *                            the temporal relationships identified during rule application
      */
-    DefaultEventTargetSequenceDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory,
-                                            ITaskTreeBuilder     taskTreeBuilder)
+    SequenceOnSameTargetDetectionRule(ITaskTreeNodeFactory taskTreeNodeFactory,
+                                      ITaskTreeBuilder     taskTreeBuilder)
     {
         this.taskTreeNodeFactory = taskTreeNodeFactory;
@@ -70 +72 @@
     @Override
     public String toString() {
-        return "DefaultEventTargetSequenceDetectionRule";
+        return "SequenceOnSameTargetDetectionRule";
     }
 
@@ -91 +93 @@
 
         int index = 0;
-        while (index < parent.getChildren().size()) {
-            ITaskTreeNode child = parent.getChildren().get(index);
+        List<ITaskTreeNode> children = parent.getChildren();
+        
+        while (index < children.size()) {
+            ITaskTreeNode child = children.get(index);
 
             IEventTarget eventTarget = determineEventTarget(child);
@@ -109 +113 @@
                     // or if this child is not a sequence itself
                     if ((startingIndex != endIndex) ||
-                        (!(parent.getChildren().get(startingIndex) instanceof ISequence)))
+                        (!(children.get(startingIndex) instanceof ISequence)))
                     {
                         handleEventTargetSequence
                             (parent, currentEventTarget, startingIndex, endIndex, result);
 
-                        result.setRuleApplicationStatus
-                            (RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+                        result.setRuleApplicationStatus(RuleApplicationStatus.FINISHED);
                         return result;
                     }
@@ -134 +137 @@
 
         if (startingIndex > -1) {
-            int endIndex = parent.getChildren().size() - 1;
+            int endIndex = children.size() - 1;
             
             if (finalize) {
@@ -141 +144 @@
                 if ((startingIndex > 0) &&
                     ((startingIndex != endIndex) ||
-                     (!(parent.getChildren().get(startingIndex) instanceof ISequence))))
+                     (!(children.get(startingIndex) instanceof ISequence))))
                 {
                     handleEventTargetSequence
                         (parent, currentEventTarget, startingIndex, endIndex, result);
                 
-                    result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+                    result.setRuleApplicationStatus(RuleApplicationStatus.FINISHED);
                 }
             }
             else {
-                result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+                result.setRuleApplicationStatus(RuleApplicationStatus.FEASIBLE);
             }
         }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeComparator.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
 
+import java.util.HashMap;
+
 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
@@ -44 +46 @@
     private NodeEquality minimalNodeEquality;
 
-
+    private Comparer comparer;
+
+    private Comparer lexicalComparer;
+
+    private StopWatch stopWatch = new StopWatch();
+    
+    private HashMap<Long, Boolean> equalityBuffer = new HashMap<Long, Boolean>();
+
+    private HashMap<Long, Boolean> lexicalEqualityBuffer;
 
     /**
@@ -60 +70 @@
         this.nodeEqualityRuleManager = nodeEqualityRuleManager;
         this.minimalNodeEquality = minimalNodeEquality;
-    }
-
-
+        
+        if (minimalNodeEquality == NodeEquality.LEXICALLY_EQUAL) {
+            comparer = new LexicalComparer();
+        }
+        else if (minimalNodeEquality == NodeEquality.SYNTACTICALLY_EQUAL) {
+            comparer = new SyntacticalComparer();
+        }
+        else if (minimalNodeEquality == NodeEquality.SEMANTICALLY_EQUAL) {
+            comparer = new SemanticalComparer();
+        }
+        else {
+            comparer = new DefaultComparer();
+        }
+        
+        if (minimalNodeEquality == NodeEquality.LEXICALLY_EQUAL) {
+            lexicalComparer = comparer;
+            lexicalEqualityBuffer = equalityBuffer;
+        }
+        else {
+            lexicalComparer = new LexicalComparer();
+            lexicalEqualityBuffer = new HashMap<Long, Boolean>();
+        }
+    }
 
     /* (non-Javadoc)
@@ -69 +99 @@
     @Override
     public boolean equals(ITaskTreeNode symbol1, ITaskTreeNode symbol2) {
-        return nodeEqualityRuleManager.applyRules(symbol1, symbol2).isAtLeast(minimalNodeEquality);
-    }
-
+        //String id = "compare " + symbol1.getClass().getSimpleName() + " " +
+        //    symbol2.getClass().getSimpleName();
+        //String id = "compare";
+        //stopWatch.start(id);
+        
+        Boolean result;
+        
+        if (symbol1 != symbol2) {
+            long key = ((long) System.identityHashCode(symbol1)) << 32;
+            key += System.identityHashCode(symbol2);
+            
+            result = equalityBuffer.get(key);
+            
+            if (result == null) {
+                result = comparer.compare(symbol1, symbol2);
+                equalityBuffer.put(key, result);
+            }
+        }
+        else {
+            result = true;
+        }
+        //stopWatch.stop(id);
+        
+        /*boolean result2 = nodeEqualityRuleManager.areAtLeastEqual(symbol1, symbol2, minimalNodeEquality);
+        if (result != result2) {
+            throw new IllegalStateException("implementation error");
+        }*/
+        
+        return result;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @return
+     */
+    StopWatch getStopWatch() {
+        return stopWatch;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @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;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @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);
+        }
+    }
 }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java

@@ -157 +157 @@
 
         treeScopeRules = new TemporalRelationshipRule[] {
+            new SequenceForTaskDetectionRule
+                (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL,
+                 taskTreeNodeFactory, taskTreeBuilder),
+            /*new DefaultTaskSequenceDetectionRule
+                (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL,
+                 taskTreeNodeFactory, taskTreeBuilder),
             new DefaultTaskSequenceDetectionRule
-                (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL,
-                 taskTreeNodeFactory, taskTreeBuilder)
+                (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL,
+                 taskTreeNodeFactory, taskTreeBuilder),*/
+            /*new TreeScopeWrapperRule
+                (new DefaultIterationDetectionRule
+                    (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL,
+                     taskTreeNodeFactory, taskTreeBuilder)),
+            new TreeScopeWrapperRule
+                (new DefaultIterationDetectionRule
+                    (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL,
+                     taskTreeNodeFactory, taskTreeBuilder)),
+            new TreeScopeWrapperRule
+                (new DefaultIterationDetectionRule
+                    (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL,
+                     taskTreeNodeFactory, taskTreeBuilder))*/
         };
         
@@ -165 +183 @@
 
         nodeScopeRules = new TemporalRelationshipRule[] {
-            //new DefaultGuiElementSequenceDetectionRule(taskTreeNodeFactory, taskTreeBuilder),
-            //new DefaultEventTargetSequenceDetectionRule(taskTreeNodeFactory, taskTreeBuilder),
+            //new SequenceOnGuiElementDetectionRule(taskTreeNodeFactory, taskTreeBuilder),
+            //new EventSequenceOnSameTargetDetectionRule(taskTreeNodeFactory, taskTreeBuilder),
             new TrackBarSelectionDetectionRule
                 (nodeEqualityRuleManager, taskTreeNodeFactory, taskTreeBuilder),
             //new DefaultGuiEventSequenceDetectionRule(taskTreeNodeFactory, taskTreeBuilder),
-            new DefaultIterationDetectionRule
-                (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL,
-                 taskTreeNodeFactory, taskTreeBuilder),
-            new DefaultIterationDetectionRule
-                (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL,
-                 taskTreeNodeFactory, taskTreeBuilder),
-            new DefaultIterationDetectionRule
-                (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL,
-                 taskTreeNodeFactory, taskTreeBuilder)
         };
 
@@ -245 +254 @@
 
                 if ((result != null) &&
-                    (result.getRuleApplicationStatus() ==
-                     RuleApplicationStatus.RULE_APPLICATION_FINISHED))
+                    (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED))
                 {
                     Console.traceln
@@ -252 +260 @@
                     noOfRuleApplications++;
                     
-                    dumpTask(parent, "");
+                    //dumpTask(parent, "");
 
                     for (ITaskTreeNode newParent : result.getNewlyCreatedParentNodes()) {
@@ -261 +269 @@
             }
             while ((result != null) &&
-                   (result.getRuleApplicationStatus() ==
-                    RuleApplicationStatus.RULE_APPLICATION_FINISHED));
+                   (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED));
 
             if ((!finalize) &&
                 (result != null) &&
-                (result.getRuleApplicationStatus() ==
-                 RuleApplicationStatus.RULE_APPLICATION_FEASIBLE))
+                (result.getRuleApplicationStatus() == RuleApplicationStatus.FEASIBLE))
             {
                 // in this case, don't go on applying rules, which should not be applied yet
@@ -275 +281 @@
 
         if (noOfRuleApplications <= 0) {
-            Console.traceln(Level.INFO, logIndent + "no rules applied --> no temporal " +
+            Console.traceln(Level.FINE, logIndent + "no rules applied --> no temporal " +
                             "relationship generated");
         }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
 
+import java.util.List;
+
 import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
 import de.ugoe.cs.autoquest.eventcore.guimodel.ITrackBar;
-import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
@@ -97 +98 @@
 
         int index = 0;
-        while (index < parent.getChildren().size()) {
-            ITaskTreeNode child = parent.getChildren().get(index);
+        List<ITaskTreeNode> children = parent.getChildren();
+        
+        while (index < children.size()) {
+            ITaskTreeNode child = children.get(index);
 
             if ((child instanceof IEventTask) &&
@@ -128 +131 @@
             if (finalize) {
                 handleValueSelections(parent, currentTrackBar, valueSelectionStartIndex,
-                                      parent.getChildren().size() - 1, result);
+                                      children.size() - 1, result);
             }
             else {
-                result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+                result.setRuleApplicationStatus(RuleApplicationStatus.FEASIBLE);
             }
         }
@@ -156 +159 @@
         taskTreeBuilder.setChild(iteration, selection);
 
+        List<ITaskTreeNode> children = parent.getChildren();
+        
         for (int i = endIndex - startIndex; i >= 0; i--) {
-            addChildIfNecessary(selection, parent.getChildren().get(startIndex), result);
+            addChildIfNecessary(selection, children.get(startIndex), result);
             taskTreeBuilder.removeChild((ISequence) parent, startIndex);
         }
@@ -163 +168 @@
         taskTreeBuilder.addChild((ISequence) parent, startIndex, iteration);
 
-        result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+        result.setRuleApplicationStatus(RuleApplicationStatus.FINISHED);
     }
 
@@ -173 +178 @@
                                      RuleApplicationResult result)
     {
-        for (int i = 0; i < parentSelection.getChildren().size(); i++) {
-            ITaskTreeNode child = parentSelection.getChildren().get(i);
+        List<ITaskTreeNode> children = parentSelection.getChildren();
+        
+        for (int i = 0; i < children.size(); i++) {
+            ITaskTreeNode child = children.get(i);
 
             // check, if the new node is a variant for the current event task
-            NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules(child, node);
-            if (nodeEquality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) {
+            if (nodeEqualityRuleManager.areSyntacticallyEqual(child, node)) {
                 return;
             }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TreeScopeWrapperRule.java

@@ -14 +14 @@
 
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import java.util.List;
 
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
@@ -69 +71 @@
             result = new RuleApplicationResult();
             
-            if (parent.getChildren() != null) {
-                for (ITaskTreeNode child : parent.getChildren()) {
+            List<ITaskTreeNode> children = parent.getChildren();
+            if (children != null) {
+                for (ITaskTreeNode child : children) {
                     merge(result, apply(child, finalize));
                 }
@@ -97 +100 @@
         RuleApplicationStatus intermediateStatus = intermediate.getRuleApplicationStatus();
         
-        if ((intermediateStatus == RuleApplicationStatus.RULE_APPLICATION_FINISHED) ||
-            ((intermediateStatus == RuleApplicationStatus.RULE_APPLICATION_FEASIBLE) &&
-             (overallStatus == RuleApplicationStatus.RULE_NOT_APPLIED)))
+        if ((intermediateStatus == RuleApplicationStatus.FINISHED) ||
+            ((intermediateStatus == RuleApplicationStatus.FEASIBLE) &&
+             (overallStatus == RuleApplicationStatus.NOT_APPLIED)))
         {
             overallResult.setRuleApplicationStatus(intermediateStatus);