Changeset 1146 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndIterationComparisonRule.java

Timestamp:

04/04/13 16:06:07 (11 years ago)

Author:

pharms

Message:

• complete refactoring of task tree model with a separation of task models and task instances
• appropriate adaptation of task tree generation process
• appropriate adaptation of commands and task tree visualization

Location:

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

Files:

• . (copied) (copied from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality)
• TaskAndIterationComparisonRule.java (copied) (copied from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndIterationComparisonRule.java) (6 diffs)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndIterationComparisonRule.java

@@ -13 +13 @@
 //   limitations under the License.
 
-package de.ugoe.cs.autoquest.tasktrees.nodeequality;
-
-import java.util.List;
+package de.ugoe.cs.autoquest.tasktrees.taskequality;
 
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 
 /**
  * <p>
- * This class is capable of comparing any task tree node which is not an iteration with an
- * iteration. This is needed, because iterations may iterate exactly that node. In this
- * case, the iteration would be equal to that node if it was executed exactly once. The rule
- * returns lexically equal, it the child of the iteration is lexically equal to the node
+ * This class is capable of comparing any task which is not an iteration with an
+ * iteration. This is needed, because iterations may iterate exactly that task. In this
+ * case, the iteration would be equal to that task if it was executed exactly once. The rule
+ * returns lexically equal, it the child of the iteration is lexically equal to the task
  * or if the child of the iteration is a selection and this selections contains a lexically equal
- * node. The same applies for syntactical and semantical equality.
+ * task. The same applies for syntactical and semantical equality.
  * </p>
 
  * @author Patrick Harms
  */
-public class NodeAndIterationComparisonRule implements NodeComparisonRule {
+public class TaskAndIterationComparisonRule implements TaskComparisonRule {
     
-    /** the rule manager for internally comparing task tree nodes */
-    private NodeEqualityRuleManager mRuleManager;
+    /** the rule manager for internally comparing tasks */
+    private TaskEqualityRuleManager mRuleManager;
 
     /**
      * <p>
-     * simple constructor to provide the rule with the node equality rule manager to be able
-     * to perform comparisons of the children of provided task tree nodes
+     * simple constructor to provide the rule with the task equality rule manager to be able
+     * to perform comparisons of the children of provided tasks
      * </p>
      * 
-     * @param ruleManager the rule manager for comparing task tree nodes
+     * @param ruleManager the rule manager for comparing tasks
      */
-    NodeAndIterationComparisonRule(NodeEqualityRuleManager ruleManager) {
+    TaskAndIterationComparisonRule(TaskEqualityRuleManager ruleManager) {
         super();
         mRuleManager = ruleManager;
@@ -51 +49 @@
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#isApplicable(ITask, ITask)
      */
     @Override
-    public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return ((node1 instanceof IIteration) && (!(node2 instanceof IIteration))) ||
-               ((node2 instanceof IIteration) && (!(node1 instanceof IIteration)));
+    public boolean isApplicable(ITask task1, ITask task2) {
+        return ((task1 instanceof IIteration) && (!(task2 instanceof IIteration))) ||
+               ((task2 instanceof IIteration) && (!(task1 instanceof IIteration)));
     }
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask)
      */
     @Override
-    public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
+    public boolean areLexicallyEqual(ITask task1, ITask task2) {
+        TaskEquality equality = getEquality(task1, task2, TaskEquality.LEXICALLY_EQUAL);
+        return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL));
     }
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask)
      */
     @Override
-    public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
+    public boolean areSyntacticallyEqual(ITask task1, ITask task2) {
+        TaskEquality equality = getEquality(task1, task2, TaskEquality.SYNTACTICALLY_EQUAL);
+        return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL));
     }
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask)
      */
     @Override
-    public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
+    public boolean areSemanticallyEqual(ITask task1, ITask task2) {
+        TaskEquality equality = getEquality(task1, task2, TaskEquality.SEMANTICALLY_EQUAL);
+        return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL));
     }
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#compare(ITask, ITask)
      */
     @Override
-    public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return getEquality(node1, node2, null);
+    public TaskEquality compare(ITask task1, ITask task2) {
+        return getEquality(task1, task2, null);
     }
 
@@ -97 +95 @@
      * 
      */
-    private NodeEquality getEquality(ITaskTreeNode node1,
-                                     ITaskTreeNode node2,
-                                     NodeEquality  requiredEqualityLevel)
-    {
+    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) {
         IIteration iteration = null;
-        ITaskTreeNode node = null;
+        ITask task = null;
         
-        if (node1 instanceof IIteration) {
-            if (node2 instanceof IIteration) {
+        if (task1 instanceof IIteration) {
+            if (task2 instanceof IIteration) {
                 // the rule is not responsible for two iterations
                 return null;
             }
             
-            iteration = (IIteration) node1;
-            node = node2;
+            iteration = (IIteration) task1;
+            task = task2;
         }
-        else if (node2 instanceof IIteration) {
-            if (node1 instanceof IIteration) {
+        else if (task2 instanceof IIteration) {
+            if (task1 instanceof IIteration) {
                 // the rule is not responsible for two iterations
                 return null;
             }
             
-            iteration = (IIteration) node2;
-            node = node1;
+            iteration = (IIteration) task2;
+            task = task1;
         }
         else {
@@ -126 +121 @@
         }
 
-        List<ITaskTreeNode> children = iteration.getChildren();
+        ITask child = iteration.getMarkedTask();
         
-        // now, that we found the iteration and the node, lets compare the child of the iteration
-        // with the node.
-        if (children.size() < 1) {
+        // now, that we found the iteration and the task, lets compare the child of the iteration
+        // with the task.
+        if (child == null) {
             return null;
         }
 
-        NodeEquality nodeEquality = callRuleManager(children.get(0), node, requiredEqualityLevel);
+        TaskEquality taskEquality = callRuleManager(child, task, requiredEqualityLevel);
 
-        // although the subtask may be identical to the node, we can not return identical, as
-        // the iteration is not identical to the node, but at most lexically equal
-        if (nodeEquality == NodeEquality.IDENTICAL) {
-            return NodeEquality.LEXICALLY_EQUAL;
+        // although the subtask may be identical to the task, we can not return identical, as
+        // the iteration is not identical to the task, but at most lexically equal
+        if (taskEquality == TaskEquality.IDENTICAL) {
+            return TaskEquality.LEXICALLY_EQUAL;
         }
         else {
-            return nodeEquality;
+            return taskEquality;
         }
 
@@ -157 +152 @@
      * @return
      */
-    private NodeEquality callRuleManager(ITaskTreeNode child1,
-                                         ITaskTreeNode child2,
-                                         NodeEquality  requiredEqualityLevel)
+    private TaskEquality callRuleManager(ITask        child1,
+                                         ITask        child2,
+                                         TaskEquality requiredEqualityLevel)
     {
         if (requiredEqualityLevel == null) {
@@ -168 +163 @@
         }
         else {
-            return NodeEquality.UNEQUAL;
+            return TaskEquality.UNEQUAL;
         }
     }