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

Timestamp:

08/14/13 17:04:42 (11 years ago)

Author:

pharms

Message:

• rework of task model to move event instance stuff to task instances
• introduction of sequence, selection, iteration and optional instances

File:

• trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/IterationComparisonRule.java (modified) (9 diffs)

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

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.taskequality;
 
-import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIterationInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 
 /**
@@ -82 +82 @@
     
     /* (non-Javadoc)
-     * @see NodeComparisonRule#isApplicable(ITask, ITask)
+     * @see TaskComparisonRule#isApplicable(ITask, ITask)
      */
     @Override
@@ -90 +90 @@
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask)
+     * @see TaskComparisonRule#areLexicallyEqual(ITask, ITask)
      */
     @Override
     public boolean areLexicallyEqual(ITask task1, ITask task2) {
-        ITask child1 = ((IIteration) task1).getMarkedTask();
-        ITask child2 = ((IIteration) task2).getMarkedTask();
-        
-        if (child1 != null) {
-            if (child2 == null) {
-                return false;
-            }
-            else {
-                // iterations may have 3 different structures.
-                // 1. they have one child, which is the iterated one
-                // 2. they have a sequence of children, which is iterated
-                // 3. they have a selection of different iterated variants (usually the variants
-                //    are semantically equal)
-                // check if the type of children match. If not, return false. If they match,
-                // use the equality manager to perform further comparisons
-                
-                if (((child1 instanceof ISelection) && (child2 instanceof ISelection)) ||
-                    ((child1 instanceof ISequence) && (child2 instanceof ISequence)) ||
-                    ((child1 instanceof IEventTask) && (child2 instanceof IEventTask)))
-                {
-                    return getNodeEquality
-                        (child1, child2).isAtLeast(TaskEquality.LEXICALLY_EQUAL);
-                }
-            }
-        }
-        else if (child2 == null) {
-            return true;
-        }
-        
-        return false;
-    }
-
-    /* (non-Javadoc)
-     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask)
-     */
-    @Override
-    public boolean areSyntacticallyEqual(ITask task1, ITask task2) {
         ITask child1 = ((IIteration) task1).getMarkedTask();
         ITask child2 = ((IIteration) task2).getMarkedTask();
@@ -146 +109 @@
                 // ignore the type of the children but check them for equality.
                 
-                return getNodeEquality(child1, child2).isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL);
+                return getNodeEquality(child1, child2).isAtLeast(TaskEquality.LEXICALLY_EQUAL);
             }
         }
@@ -157 +120 @@
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask)
+     * @see TaskComparisonRule#areSyntacticallyEqual(ITask, ITask)
+     */
+    @Override
+    public boolean areSyntacticallyEqual(ITask task1, ITask task2) {
+        return areLexicallyEqual(task1, task2);
+    }
+
+    /* (non-Javadoc)
+     * @see TaskComparisonRule#areSemanticallyEqual(ITask, ITask)
      */
     @Override
@@ -165 +136 @@
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#compare(ITask, ITask)
+     * @see TaskComparisonRule#compare(ITask, ITask)
      */
     @Override
@@ -203 +174 @@
         // all other combinations (i.e. sequence with single child and sequence with selection)
         // can not match
+    }
+
+    /* (non-Javadoc)
+     * @see TaskComparisonRule#isApplicable(ITaskInstance, ITaskInstance)
+     */
+    @Override
+    public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2) {
+        return isApplicable(instance1.getTask(), instance2.getTask());
+    }
+
+    /* (non-Javadoc)
+     * @see TaskComparisonRule#areLexicallyEqual(ITaskInstance, ITaskInstance)
+     */
+    @Override
+    public boolean areLexicallyEqual(ITaskInstance instance1, ITaskInstance instance2) {
+        IIterationInstance iteration1 = (IIterationInstance) instance1;
+        IIterationInstance iteration2 = (IIterationInstance) instance2;
+
+        // if both sequences do not have children, they are equal although this doesn't make sense
+        if ((iteration1.size() == 0) && (iteration2.size() == 0)) {
+            return true;
+        }
+
+        if (iteration1.size() != iteration2.size()) {
+            return false;
+        }
+
+        for (int i = 0; i < iteration1.size(); i++) {
+            ITaskInstance child1 = iteration1.get(i);
+            ITaskInstance child2 = iteration2.get(i);
+
+            TaskEquality taskEquality =
+                callRuleManager(child1, child2, TaskEquality.LEXICALLY_EQUAL);
+
+            if ((taskEquality == null) || (taskEquality == TaskEquality.UNEQUAL)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /* (non-Javadoc)
+     * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance, ITaskInstance)
+     */
+    @Override
+    public boolean areSyntacticallyEqual(ITaskInstance instance1, ITaskInstance instance2) {
+        return areLexicallyEqual(instance1, instance2);
+    }
+
+    /* (non-Javadoc)
+     * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance, ITaskInstance)
+     */
+    @Override
+    public boolean areSemanticallyEqual(ITaskInstance instance1, ITaskInstance instance2) {
+        return areLexicallyEqual(instance1, instance2);
+    }
+
+    /* (non-Javadoc)
+     * @see TaskComparisonRule#compare(ITaskInstance, ITaskInstance)
+     */
+    @Override
+    public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2) {
+        if (areLexicallyEqual(instance1, instance2)) {
+            return TaskEquality.LEXICALLY_EQUAL;
+        }
+        else {
+            return TaskEquality.UNEQUAL;
+        }
     }
 
@@ -272 +312 @@
                   callRuleManager(task, child, commonDenominatorForAllComparisons);
 
-            if ((taskEquality == null) || (taskEquality == TaskEquality.UNEQUAL))
-            {
+            if ((taskEquality == null) || (taskEquality == TaskEquality.UNEQUAL)) {
                 return TaskEquality.UNEQUAL;
             }
@@ -314 +353 @@
         }
     }
+    
+    /**
+     * <p>
+     * used to to call the task equality rule manager for the comparison of the two provided
+     * children. If no required equality level is provided, than the most concrete equality is
+     * returned. Otherwise, the required equality is returned as long as the children are equal
+     * on that level.
+     * </p> 
+     * 
+     * @param taskInstance1         the first task instance to be compared
+     * @param taskInstance2         the second task instance to be compared
+     * @param requiredEqualityLevel the equality level to be checked for
+     * 
+     * @return the determined equality
+     */
+    private TaskEquality callRuleManager(ITaskInstance taskInstance1,
+                                         ITaskInstance taskInstance2,
+                                         TaskEquality  requiredEqualityLevel)
+    {
+        if (requiredEqualityLevel == null) {
+            return TaskEqualityRuleManager.getInstance().compare(taskInstance1, taskInstance2);
+        }
+        else if (TaskEqualityRuleManager.getInstance().areAtLeastEqual
+                     (taskInstance1, taskInstance2, requiredEqualityLevel))
+        {
+            return requiredEqualityLevel;
+        }
+        else {
+            return TaskEquality.UNEQUAL;
+        }
+    }
 }