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

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

@@ -13 +13 @@
 //   limitations under the License.
 
-package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+package de.ugoe.cs.autoquest.tasktrees.taskequality;
 
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 
 /**
  * <p>
- * This rule identifies two task tree nodes as lexically equal, if they are both event tasks and
+ * This rule identifies two tasks as lexically equal, if they are both event tasks and
  * if their respective event types and targets equal. 
  * </p>
@@ -26 +26 @@
  * @author Patrick Harms
  */
-public class EventTaskComparisonRule implements NodeComparisonRule {
+public class EventTaskComparisonRule implements TaskComparisonRule {
     
     /* (non-Javadoc)
-     * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#isApplicable(ITask, ITask)
      */
     @Override
-    public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return (node1 instanceof IEventTask) && (node2 instanceof IEventTask);
+    public boolean isApplicable(ITask task1, ITask task2) {
+        return (task1 instanceof IEventTask) && (task2 instanceof IEventTask);
     }
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask)
      */
     @Override
-    public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        IEventTask task1 = (IEventTask) node1;
-        IEventTask task2 = (IEventTask) node2;
+    public boolean areLexicallyEqual(ITask task1, ITask task2) {
+        IEventTask eventTask1 = (IEventTask) task1;
+        IEventTask eventTask2 = (IEventTask) task2;
         
-        return (task1.getEventType().equals(task2.getEventType()) &&
-                task1.getEventTarget().equals(task2.getEventTarget()));
+        return (eventTask1.getEventType().equals(eventTask2.getEventType()) &&
+                eventTask1.getEventTarget().equals(eventTask2.getEventTarget()));
     }
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask)
      */
     @Override
-    public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return areLexicallyEqual(node1, node2);
+    public boolean areSyntacticallyEqual(ITask task1, ITask task2) {
+        return areLexicallyEqual(task1, task2);
     }
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode)
+     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask)
      */
     @Override
-    public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return areLexicallyEqual(node1, node2);
+    public boolean areSemanticallyEqual(ITask task1, ITask task2) {
+        return areLexicallyEqual(task1, task2);
     }
 
     @Override
-    public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
-        if (areLexicallyEqual(node1, node2)) {
-            return NodeEquality.LEXICALLY_EQUAL;
+    public TaskEquality compare(ITask task1, ITask task2) {
+        if (areLexicallyEqual(task1, task2)) {
+            return TaskEquality.LEXICALLY_EQUAL;
         }
         else {
-            return NodeEquality.UNEQUAL;
+            return TaskEquality.UNEQUAL;
         }
     }