Changeset 1146 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndSelectionComparisonRule.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)
• TaskAndSelectionComparisonRule.java (copied) (copied from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java) (10 diffs)

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

@@ -13 +13 @@
 //   limitations under the License.
 
-package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+package de.ugoe.cs.autoquest.tasktrees.taskequality;
 
 import java.util.List;
 
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
-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 a selection with a
- * selection. This is needed, because selections may contain exactly that node. Therefore, if
- * this node is selected out of a selection the selection is equal to the node itself. 
- * The rule returns lexically equal, it the selection contains a lexically equal node. The same
+ * This class is capable of comparing any task which is not a selection with a
+ * selection. This is needed, because selections may contain exactly that task. Therefore, if
+ * this task is selected out of a selection the selection is equal to the task itself. 
+ * The rule returns lexically equal, if the selection contains a lexically equal task. The same
  * applies for syntactical and semantical equality.
  * </p>
@@ -31 +31 @@
  * @author Patrick Harms
  */
-public class NodeAndSelectionComparisonRule implements NodeComparisonRule {
+public class TaskAndSelectionComparisonRule 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
      */
-    NodeAndSelectionComparisonRule(NodeEqualityRuleManager ruleManager) {
+    TaskAndSelectionComparisonRule(TaskEqualityRuleManager ruleManager) {
         super();
         mRuleManager = ruleManager;
@@ -50 +50 @@
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#isApplicable(ITask, ITask)
      */
     @Override
-    public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return ((node1 instanceof ISelection) && (!(node2 instanceof ISelection))) ||
-               ((node2 instanceof ISelection) && (!(node1 instanceof ISelection)));
+    public boolean isApplicable(ITask task1, ITask task2) {
+        return ((task1 instanceof ISelection) && (!(task2 instanceof ISelection))) ||
+               ((task2 instanceof ISelection) && (!(task1 instanceof ISelection)));
     }
 
     /* (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);
     }
     
@@ -96 +96 @@
      * 
      */
-    private NodeEquality getEquality(ITaskTreeNode node1,
-                                     ITaskTreeNode node2,
-                                     NodeEquality  requiredEqualityLevel)
-    {
+    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) {
         ISelection selection = null;
-        ITaskTreeNode node = null;
+        ITask task = null;
         
-        if (node1 instanceof ISelection) {
-            if (node2 instanceof ISelection) {
+        if (task1 instanceof ISelection) {
+            if (task2 instanceof ISelection) {
                 // the rule is not responsible for two selections
                 return null;
             }
             
-            selection = (ISelection) node1;
-            node = node2;
+            selection = (ISelection) task1;
+            task = task2;
         }
-        else if (node2 instanceof ISelection) {
-            if (node1 instanceof ISelection) {
+        else if (task2 instanceof ISelection) {
+            if (task1 instanceof ISelection) {
                 // the rule is not responsible for two selections
                 return null;
             }
             
-            selection = (ISelection) node2;
-            node = node1;
+            selection = (ISelection) task2;
+            task = task1;
         }
         else {
@@ -125 +122 @@
         }
 
-        // now, that we found the selection and the node, lets compare the children of the selection
-        // with the node.
-        List<ITaskTreeNode> children = selection.getChildren();
+        // now, that we found the selection and the task, lets compare the children of the selection
+        // with the task.
+        List<ITask> children = selection.getChildren();
         
         if (children.size() < 1) {
@@ -133 +130 @@
         }
 
-        NodeEquality mostConcreteNodeEquality = null;
+        TaskEquality mostConcreteNodeEquality = null;
         
-        for (ITaskTreeNode child : children) {
-            NodeEquality nodeEquality = callRuleManager(child, node, requiredEqualityLevel);
+        for (ITask child : children) {
+            TaskEquality taskEquality = callRuleManager(child, task, requiredEqualityLevel);
             
-            if (nodeEquality != NodeEquality.UNEQUAL) {
+            if (taskEquality != TaskEquality.UNEQUAL) {
                 if (mostConcreteNodeEquality == null) {
-                    mostConcreteNodeEquality = nodeEquality;
+                    mostConcreteNodeEquality = taskEquality;
                 }
-                else if (mostConcreteNodeEquality.isAtLeast(nodeEquality)) {
-                    mostConcreteNodeEquality = nodeEquality;
+                else if (mostConcreteNodeEquality.isAtLeast(taskEquality)) {
+                    mostConcreteNodeEquality = taskEquality;
                     
                 }
@@ -151 +148 @@
                 {
                     // if we found one child of the selection that is as equal as required, then
-                    // we can consider the selection to be sufficiently equal to the other node.
+                    // we can consider the selection to be sufficiently equal to the other task.
                     // So we break up checking further children.
                     break;
@@ -158 +155 @@
         }
         
-        // although the subtask may be identical to the node, we can not return identical, as
-        // the selection is not identical to the node, but at most lexically equal
-        if (mostConcreteNodeEquality == NodeEquality.IDENTICAL) {
-            return NodeEquality.LEXICALLY_EQUAL;
+        // although the subtask may be identical to the task, we can not return identical, as
+        // the selection is not identical to the task, but at most lexically equal
+        if (mostConcreteNodeEquality == TaskEquality.IDENTICAL) {
+            return TaskEquality.LEXICALLY_EQUAL;
         }
         else {
@@ -179 +176 @@
      * @return
      */
-    private NodeEquality callRuleManager(ITaskTreeNode child1,
-                                         ITaskTreeNode child2,
-                                         NodeEquality  requiredEqualityLevel)
+    private TaskEquality callRuleManager(ITask        child1,
+                                         ITask        child2,
+                                         TaskEquality requiredEqualityLevel)
     {
         if (requiredEqualityLevel == null) {
@@ -190 +187 @@
         }
         else {
-            return NodeEquality.UNEQUAL;
+            return TaskEquality.UNEQUAL;
         }
     }