Changeset 1107 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java

Timestamp:

02/21/13 18:39:13 (11 years ago)

Author:

pharms

Message:

• changed rules to be testable on their own
• added first version for a task detection rule
• refactored rules to have a simpler interface

File:

• trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java (modified) (12 diffs)

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

@@ -20 +20 @@
  * @author 2012, last modified by $Author: patrick$
  */
-public class DefaultGuiElementSequenceDetectionRule implements TemporalRelationshipRule {
-
+class DefaultGuiElementSequenceDetectionRule implements TemporalRelationshipRule {
+
+    /**
+     * <p>
+     * the task tree node factory to be used for creating substructures for the temporal
+     * relationships identified during rule
+     * </p>
+     */
+    private ITaskTreeNodeFactory taskTreeNodeFactory;
+    /**
+     * <p>
+     * the task tree builder to be used for creating substructures for the temporal relationships
+     * identified during rule application
+     * </p>
+     */
+    private ITaskTreeBuilder taskTreeBuilder;
+    
     /**
      * <p>
@@ -31 +46 @@
     /**
      * <p>
-     * instantiates the rule without a GUI element filter
-     * </p>
-     */
-    DefaultGuiElementSequenceDetectionRule() {
-        this.guiElementFilter = null;
-    }
-
+     * instantiates the rule with a task tree node factory and builder to be used during rule
+     * application but without a GUI element filter
+     * </p>
+     * 
+     * @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);
+    }
+    
     /**
      * <p>
@@ -45 +69 @@
      * </p>
      *
-     * @param guiElementFilter the GUI element filter to be applied
-     */
-    DefaultGuiElementSequenceDetectionRule(List<Class<? extends IGUIElement>> guiElementFilter) {
+     * @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<Class<? extends IGUIElement>> guiElementFilter,
+                                           ITaskTreeNodeFactory taskTreeNodeFactory,
+                                           ITaskTreeBuilder     taskTreeBuilder)
+    {
         this.guiElementFilter = guiElementFilter;
+        this.taskTreeNodeFactory = taskTreeNodeFactory;
+        this.taskTreeBuilder = taskTreeBuilder;
     }
 
@@ -55 +89 @@
      * 
      * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode,
-     * TaskTreeBuilder, TaskTreeNodeFactory)
+     * boolean)
      */
     @Override
-    public RuleApplicationResult apply(ITaskTreeNode        parent,
-                                       ITaskTreeBuilder     builder,
-                                       ITaskTreeNodeFactory nodeFactory,
-                                       boolean              finalize)
-    {
+    public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) {
         if (!(parent instanceof ISequence)) {
             return null;
@@ -95 +125 @@
         // anything.
         
-        RuleApplicationStatus status;
+        RuleApplicationStatus status = null;
         if (initialHierarchyLevel < maxHierarchyDepth) {
-            status = generateSubSequences(parent, hierarchies, initialHierarchyLevel, finalize,
-                                          builder, nodeFactory, result);
-        }
-        else {
+            status = generateSubSequences
+                (parent, hierarchies, initialHierarchyLevel, finalize, result);
+        }
+        
+        if (status == null) {
             status = RuleApplicationStatus.RULE_NOT_APPLIED;
         }
@@ -121 +152 @@
      * @param maxHierarchyDepth the maximum hierarchy depth that may apply in this application
      * @param finalize          true, if the application shall be finalized, false else
-     * @param builder           the builder to use for generating the tree structure
-     * @param nodeFactory       the node factory to use for generating the tree structure
      * @param result            the result of the rule application to add newly created parent
      *                          nodes to
@@ -136 +165 @@
                                                        int                     hierarchyLevel,
                                                        boolean                 finalize,
-                                                       ITaskTreeBuilder        builder,
-                                                       ITaskTreeNodeFactory    nodeFactory,
                                                        RuleApplicationResult   result)
     {
@@ -169 +196 @@
             }
             else if (nextGuiElementDiffers) {
-                status = condenseSequence(parent, hierarchies, hierarchyLevel, startingIndex,
-                                          index - 1, builder, nodeFactory, result);
+                status = condenseSequence
+                    (parent, hierarchies, hierarchyLevel, startingIndex, index - 1, result);
 
                 if (status != null) {
@@ -195 +222 @@
                 status = condenseSequence
                     (parent, hierarchies, hierarchyLevel, startingIndex,
-                     parent.getChildren().size() - 1, builder, nodeFactory, result);
+                     parent.getChildren().size() - 1, result);
             }
             else if (status != RuleApplicationStatus.RULE_APPLICATION_FINISHED) {
@@ -225 +252 @@
      * @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 builder        the builder to use for generating the tree structure
-     * @param nodeFactory    the node factory to use for generating the tree structure
      * @param result         the result of the rule application to add newly created parent nodes to
      * 
@@ -238 +263 @@
                                                    int                     startIndex,
                                                    int                     endIndex,
-                                                   ITaskTreeBuilder        builder,
-                                                   ITaskTreeNodeFactory    nodeFactory,
                                                    RuleApplicationResult   result)
     {
@@ -247 +270 @@
 
         if (!onlyASingleChildToReduce || !singleChildIsSequence) {
-            ISequence sequence = nodeFactory.createNewSequence();
+            ISequence sequence = taskTreeNodeFactory.createNewSequence();
             
             List<List<IGUIElement>> subHierarchies = new ArrayList<List<IGUIElement>>();
             List<IGUIElement> newHierarchy =
                 hierarchies.get(startIndex).subList(0, hierarchyLevel + 1);
-            builder.setDescription(sequence, "interactions on " +
-                                   newHierarchy.get(newHierarchy.size() - 1).getStringIdentifier());
+            taskTreeBuilder.setDescription
+                (sequence, "interactions on " +
+                 newHierarchy.get(newHierarchy.size() - 1).getStringIdentifier());
 
             for (int i = startIndex; i <= endIndex; i++) {
-                builder.addChild(sequence, parent.getChildren().get(startIndex));
-                builder.removeChild((ISequence) parent, startIndex);
+                taskTreeBuilder.addChild(sequence, parent.getChildren().get(startIndex));
+                taskTreeBuilder.removeChild((ISequence) parent, startIndex);
                 
                 subHierarchies.add(hierarchies.remove(startIndex));
             }
 
-            builder.addChild((ISequence) parent, startIndex, sequence);
+            taskTreeBuilder.addChild((ISequence) parent, startIndex, sequence);
             
             hierarchies.add(startIndex, newHierarchy);
             
-            generateSubSequences
-                (sequence, subHierarchies, hierarchyLevel + 1, true, builder, nodeFactory, result);
+            generateSubSequences(sequence, subHierarchies, hierarchyLevel + 1, true, result);
 
             result.addNewlyCreatedParentNode(sequence);