Changeset 805

Timestamp:

09/10/12 17:31:34 (12 years ago)

Author:

pharms

Message:

• added support for more fine grained iteration detection with distinction of the different levels of GUI design, i.e. lexical, syntactical and semantical.

Location:

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

Files:

• DefaultIterationDetectionRule.java (modified) (5 diffs)
• TemporalRelationshipRuleManager.java (modified) (2 diffs)

trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java

@@ -24 +24 @@
     private NodeEqualityRuleManager nodeEqualityRuleManager;
 
+    /** */
+    private NodeEquality minimalNodeEquality;
+
     /**
      * TODO: comment
      * 
      */
-    DefaultIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager) {
+    DefaultIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager,
+                                  NodeEquality            minimalNodeEquality)
+    {
         super();
         this.nodeEqualityRuleManager = nodeEqualityRuleManager;
+        this.minimalNodeEquality = minimalNodeEquality;
     }
 
@@ -64 +70 @@
 
                 if (equalVariants != null) {
-                    if (!finalize) {
-                        // check, if the iteration may go on. This may be the case, if the detected
-                        // iteration finishes with the last child of the parent, or if the
-                        // remaining children, which were not identified as part of the iteration,
-                        // start a further occurrence of the iteration
-                        if (end == (parent.getChildren().size() - 1)) {
-                            RuleApplicationResult result = new RuleApplicationResult();
-                            result.setRuleApplicationStatus
+                    RuleApplicationResult result = new RuleApplicationResult();
+                    
+                    if ((!finalize) && (iterationMayContinue(equalVariants, parent, end + 1))) {
+                        result.setRuleApplicationStatus
                               (RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
-                            return result;
-                        }
-
-                        boolean allNodesEqual = true;
-                        for (int i = 0; ((allNodesEqual) && (i < equalVariants.get(0).length)); i++)
-                        {
-                            if ((end + i + 1) >= parent.getChildren().size()) {
-                                break;
-                            }
-
-                            NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules
-                                (equalVariants.get(0)[i], parent.getChildren().get(end + i + 1));
-
-                            allNodesEqual &=
-                                nodeEquality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL);
-                        }
-
-                        if (allNodesEqual) {
-                            RuleApplicationResult result = new RuleApplicationResult();
-                            result.setRuleApplicationStatus
-                                (RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
-                            return result;
-                        }
+                        return result;
                     }
 
-                    RuleApplicationResult result = new RuleApplicationResult();
-                    IIteration newIteration = nodeFactory.createNewIteration();
-                    result.addNewlyCreatedParentNode(newIteration);
-
-                    if (equalVariants.size() == 1) {
-                        // all children are the same. Create an iteration of this child
-                        if (equalVariants.get(0).length == 1) {
-                            // all children are the same. Create an iteration of this child
-                            treeBuilder.setChild(newIteration, equalVariants.get(0)[0]);
-                        }
-                        else {
-                            // there was an iteration of structurally equal sequences
-                            ISequence sequence = nodeFactory.createNewSequence();
-                            result.addNewlyCreatedParentNode(sequence);
-
-                            for (ITaskTreeNode node : equalVariants.get(0)) {
-                                treeBuilder.addChild(sequence, node);
-                            }
-
-                            treeBuilder.setChild(newIteration, sequence);
-                        }
-                    }
-                    else {
-                        // there are distinct variants of semantically equal subsequences or
-                        // children -->
-                        // create an iterated selection
-                        ISelection selection = nodeFactory.createNewSelection();
-                        result.addNewlyCreatedParentNode(selection);
-
-                        for (ITaskTreeNode[] variant : equalVariants) {
-                            if (variant.length == 1) {
-                                treeBuilder.addChild(selection, variant[0]);
-                            }
-                            else {
-                                ISequence sequence = nodeFactory.createNewSequence();
-                                result.addNewlyCreatedParentNode(sequence);
-
-                                for (ITaskTreeNode node : variant) {
-                                    treeBuilder.addChild(sequence, node);
-                                }
-
-                                treeBuilder.addChild(selection, sequence);
-                            }
-                        }
-
-                        treeBuilder.setChild(newIteration, selection);
-                    }
+                    IIteration newIteration = createIterationBasedOnIdentifiedVariants
+                         (equalVariants, treeBuilder, nodeFactory, result);
+                    
 
                     // remove iterated children
@@ -193 +129 @@
 
     /**
-   *
-   */
+     *
+     */
     private List<ITaskTreeNode[]> getEqualSublistVariantsForSubListLength(ITaskTreeNode parent,
                                                                           int           start,
@@ -217 +153 @@
                     (firstVariant[i], parent.getChildren().get(parentIdx + i));
 
-                if (!nodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)) {
-                    if (nodeEquality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)) {
-                        otherVariant[i] = parent.getChildren().get(parentIdx + i);
-                    }
-                    else {
-                        return null;
-                    }
-                }
-            }
-
-            // check, if there is a semantically equal other variant. If so, add it to the list of
-            // variants
+                if (!nodeEquality.isAtLeast(minimalNodeEquality)) {
+                    return null;
+                }
+                else if (!nodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)) {
+                    // if the node is a syntactical or semantical equivalent of the first variant,
+                    // then store it.
+                    otherVariant[i] = parent.getChildren().get(parentIdx + i);
+                }
+            }
+
+            // check, if there is a syntactically or semantically equal other variant. If so, add
+            // it to the list of variants
             boolean semanticallyUnequal = false;
             for (int i = 0; i < subListLen; i++) {
@@ -247 +183 @@
     }
 
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param equalVariants
+     * @param parent
+     * @return
+     */
+    private boolean iterationMayContinue(List<ITaskTreeNode[]> equalVariants,
+                                         ITaskTreeNode         parent,
+                                         int                   remainderIndex)
+    {
+        // check, if the iteration may go on. This may be the case, if the
+        // remaining children, which were not identified as part of the iteration,
+        // start a further occurrence of the iteration
+
+        boolean allNodesEqual = true;
+        for (int i = 0; ((allNodesEqual) && (i < equalVariants.get(0).length)); i++)
+        {
+            if ((remainderIndex + i) >= parent.getChildren().size()) {
+                break;
+            }
+
+            NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules
+                (equalVariants.get(0)[i], parent.getChildren().get(remainderIndex + i));
+
+            allNodesEqual &= nodeEquality.isAtLeast(minimalNodeEquality);
+        }
+
+        return allNodesEqual;
+    }
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param equalVariants
+     * @param result
+     * @return
+     */
+    private IIteration createIterationBasedOnIdentifiedVariants(List<ITaskTreeNode[]> equalVariants,
+                                                                ITaskTreeBuilder      treeBuilder,
+                                                                ITaskTreeNodeFactory  nodeFactory,
+                                                                RuleApplicationResult result)
+    {
+        IIteration newIteration = nodeFactory.createNewIteration();
+        result.addNewlyCreatedParentNode(newIteration);
+
+        if (equalVariants.size() == 1) {
+            // all children are the same. Create an iteration of this child
+            if (equalVariants.get(0).length == 1) {
+                // all children are the same. Create an iteration of this child
+                treeBuilder.setChild(newIteration, equalVariants.get(0)[0]);
+            }
+            else {
+                // there was an iteration of structurally equal sequences
+                ISequence sequence = nodeFactory.createNewSequence();
+                result.addNewlyCreatedParentNode(sequence);
+
+                for (ITaskTreeNode node : equalVariants.get(0)) {
+                    treeBuilder.addChild(sequence, node);
+                }
+
+                treeBuilder.setChild(newIteration, sequence);
+            }
+        }
+        else {
+            // there are distinct variants of semantically equal subsequences or
+            // children -->
+            // create an iterated selection
+            ISelection selection = nodeFactory.createNewSelection();
+            result.addNewlyCreatedParentNode(selection);
+
+            for (ITaskTreeNode[] variant : equalVariants) {
+                if (variant.length == 1) {
+                    treeBuilder.addChild(selection, variant[0]);
+                }
+                else {
+                    ISequence sequence = nodeFactory.createNewSequence();
+                    result.addNewlyCreatedParentNode(sequence);
+
+                    for (ITaskTreeNode node : variant) {
+                        treeBuilder.addChild(sequence, node);
+                    }
+
+                    treeBuilder.addChild(selection, sequence);
+                }
+            }
+
+            treeBuilder.setChild(newIteration, selection);
+        }
+        
+        return newIteration;
+    }
+
 }

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

@@ -5 +5 @@
 import java.util.logging.Level;
 
+import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEquality;
 import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager;
 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder;
@@ -43 +44 @@
         ruleIndex.add(new TrackBarSelectionDetectionRule(nodeEqualityRuleManager));
         ruleIndex.add(new DefaultGuiEventSequenceDetectionRule());
-        ruleIndex.add(new DefaultIterationDetectionRule(nodeEqualityRuleManager));
+        
+        ruleIndex.add(new DefaultIterationDetectionRule
+                          (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL));
+        ruleIndex.add(new DefaultIterationDetectionRule
+                          (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL));
+        ruleIndex.add(new DefaultIterationDetectionRule
+                          (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL));
     }