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

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRule.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 node comparison rule is capable of comparing selections. If both selections do not have
- * children, they are treated as identical. If they have children, each child of both selections
- * is compared to each child of the respective other selection. The resulting equality is the most
- * concrete one of all these comparisons. I.e. if all children are at least lexically equal, then
- * the selections are lexically equal. If all children are at least syntactically equal, then the
- * selections are syntactically equal. If all children are at least semantically equal, then the
- * selections are semantically equal. If only one of the selections has children, then the
- * selections are unequal.
+ * this task comparison rule is capable of comparing selections. If both selections do not have
+ * children, they are treated as lexically equal. If they have children, each child of both
+ * selections is compared to each child of the respective other selection. The resulting equality
+ * is the most concrete one of all these comparisons. I.e. if all children are at least lexically
+ * equal, then the selections are lexically equal. If all children are at least syntactically
+ * equal, then the selections are syntactically equal. If all children are at least semantically
+ * equal, then the selections are semantically equal. If only one of the selections has children,
+ * then the selections are unequal.
  * </p>
  * 
@@ -35 +35 @@
  * @author 2012, last modified by $Author: patrick$
  */
-public class SelectionComparisonRule implements NodeComparisonRule {
-
-    /** the rule manager for internally comparing task tree nodes */
-    private NodeEqualityRuleManager 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
+public class SelectionComparisonRule implements TaskComparisonRule {
+
+    /** the rule manager for internally comparing tasks */
+    private TaskEqualityRuleManager mRuleManager;
+
+    /**
+     * <p>
+     * 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
-     */
-    SelectionComparisonRule(NodeEqualityRuleManager ruleManager) {
+     * @param ruleManager the rule manager for comparing tasks
+     */
+    SelectionComparisonRule(TaskEqualityRuleManager ruleManager) {
         super();
         mRuleManager = ruleManager;
@@ -54 +54 @@
 
     /* (non-Javadoc)
-     * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode)
-     */
-    @Override
-    public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return (node1 instanceof ISelection) && (node2 instanceof ISelection);
-    }
-
-    /* (non-Javadoc)
-     * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode)
-     */
-    @Override
-    public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
-    }
-
-    /* (non-Javadoc)
-     * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode)
-     */
-    @Override
-    public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
-    }
-
-    /* (non-Javadoc)
-     * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode)
-     */
-    @Override
-    public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
-    }
-
-    /* (non-Javadoc)
-     * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode)
-     */
-    @Override
-    public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
-        return getEquality(node1, node2, null);
+     * @see NodeComparisonRule#isApplicable(ITask, ITask)
+     */
+    @Override
+    public boolean isApplicable(ITask task1, ITask task2) {
+        return (task1 instanceof ISelection) && (task2 instanceof ISelection);
+    }
+
+    /* (non-Javadoc)
+     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask)
+     */
+    @Override
+    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(ITask, ITask)
+     */
+    @Override
+    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(ITask, ITask)
+     */
+    @Override
+    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(ITask, ITask)
+     */
+    @Override
+    public TaskEquality compare(ITask task1, ITask task2) {
+        return getEquality(task1, task2, null);
     }
 
@@ -99 +99 @@
      * 
      */
-    private NodeEquality getEquality(ITaskTreeNode node1,
-                                     ITaskTreeNode node2,
-                                     NodeEquality  requiredEqualityLevel)
-    {
-        List<ITaskTreeNode> children1 = node1.getChildren();
-        List<ITaskTreeNode> children2 = node2.getChildren();
+    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) {
+        List<ITask> children1 = ((ISelection) task1).getChildren();
+        List<ITask> children2 = ((ISelection) task2).getChildren();
 
         // if both selections do not have children, they are lexically equal. If only one of them
         // has children, they are unequal.
         if ((children1.size() == 0) && (children2.size() == 0)) {
-            return NodeEquality.LEXICALLY_EQUAL;
+            return TaskEquality.LEXICALLY_EQUAL;
         }
         else if ((children1.size() == 0) || (children2.size() == 0)) {
-            return NodeEquality.UNEQUAL;
-        }
-
-        NodeEquality selectionEquality;
+            return TaskEquality.UNEQUAL;
+        }
+
+        TaskEquality selectionEquality;
 
         if (requiredEqualityLevel == null) {
@@ -121 +118 @@
             // do it in both directions to ensure commutative comparison
             selectionEquality = getCommonEqualityLevel(children1, children2);
-            if (selectionEquality != NodeEquality.UNEQUAL) {
+            if (selectionEquality != TaskEquality.UNEQUAL) {
                 return selectionEquality.getCommonDenominator
                     (getCommonEqualityLevel(children2, children1));
             }
             else {
-                return NodeEquality.UNEQUAL;
+                return TaskEquality.UNEQUAL;
             }
         }
@@ -137 +134 @@
             }
             else {
-                return NodeEquality.UNEQUAL;
+                return TaskEquality.UNEQUAL;
             }
         }
@@ -151 +148 @@
      * @param requiredEqualityLevel
      */
-    private NodeEquality getCommonEqualityLevel(List<ITaskTreeNode> children1,
-                                                List<ITaskTreeNode> children2)
-    {
-        NodeEquality listEquality = NodeEquality.LEXICALLY_EQUAL;
+    private TaskEquality getCommonEqualityLevel(List<ITask> children1, List<ITask> children2) {
+        TaskEquality listEquality = TaskEquality.LEXICALLY_EQUAL;
         
-        NodeEquality childEquality;
-        NodeEquality currentEquality;
-        for (ITaskTreeNode child1 : children1) {
+        TaskEquality childEquality;
+        TaskEquality currentEquality;
+        for (ITask child1 : children1) {
             childEquality = null;
-            for (ITaskTreeNode child2 : children2) {
+            for (ITask child2 : children2) {
                 currentEquality = callRuleManager(child1, child2, null);
-                if ((currentEquality != null) && (currentEquality != NodeEquality.UNEQUAL)) {
+                if ((currentEquality != null) && (currentEquality != TaskEquality.UNEQUAL)) {
                     if (childEquality == null) {
                         childEquality = currentEquality;
@@ -170 +165 @@
                     }
                     
-                    if (childEquality == NodeEquality.SEMANTICALLY_EQUAL) {
+                    if (childEquality == TaskEquality.SEMANTICALLY_EQUAL) {
                         // as we calculate only the common denominator, we can break up here for
                         // the current child. We will not improve the denominator anymore
@@ -181 +176 @@
                 // we did not find any child in the second list, that is equal to the searched
                 // child
-                return NodeEquality.UNEQUAL;
+                return TaskEquality.UNEQUAL;
             }
             else {
@@ -200 +195 @@
      * @param requiredEqualityLevel
      */
-    private boolean checkEqualityLevel(List<ITaskTreeNode> children1,
-                                       List<ITaskTreeNode> children2,
-                                       NodeEquality        requiredEqualityLevel)
+    private boolean checkEqualityLevel(List<ITask>  children1,
+                                       List<ITask>  children2,
+                                       TaskEquality requiredEqualityLevel)
     {
-        NodeEquality childEquality;
-        NodeEquality currentEquality;
-        for (ITaskTreeNode child1 : children1) {
+        TaskEquality childEquality;
+        TaskEquality currentEquality;
+        for (ITask child1 : children1) {
             childEquality = null;
-            for (ITaskTreeNode child2 : children2) {
+            for (ITask child2 : children2) {
                 currentEquality = callRuleManager(child1, child2, requiredEqualityLevel);
                 if ((currentEquality != null) && (currentEquality.isAtLeast(requiredEqualityLevel)))
@@ -240 +235 @@
      * @return
      */
-    private NodeEquality callRuleManager(ITaskTreeNode child1,
-                                         ITaskTreeNode child2,
-                                         NodeEquality  requiredEqualityLevel)
+    private TaskEquality callRuleManager(ITask        child1,
+                                         ITask        child2,
+                                         TaskEquality requiredEqualityLevel)
     {
         if (requiredEqualityLevel == null) {
@@ -251 +246 @@
         }
         else {
-            return NodeEquality.UNEQUAL;
+            return TaskEquality.UNEQUAL;
         }
     }