Index: branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRule.java
===================================================================
--- branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRule.java	(revision 1646)
+++ branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRule.java	(revision 1733)
@@ -24,13 +24,15 @@
 /**
  * <p>
- * 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. The comparison is broken up, if only a specific equality is
- * checked for and this equality is ensured.
+ * 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. The comparison is broken up, if only a specific
+ * equality is checked for and this equality is ensured.
  * </p>
  * 
@@ -40,308 +42,363 @@
 public class SelectionComparisonRule implements TaskComparisonRule {
 
-    /* (non-Javadoc)
-     * @see TaskComparisonRule#isApplicable(ITask, ITask)
-     */
-    @Override
-    public boolean isApplicable(ITask task1, ITask task2) {
-        return (task1 instanceof ISelection) && (task2 instanceof ISelection);
-    }
-
-    /* (non-Javadoc)
-     * @see TaskComparisonRule#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 TaskComparisonRule#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 TaskComparisonRule#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 TaskComparisonRule#compare(ITask, ITask)
-     */
-    @Override
-    public TaskEquality compare(ITask task1, ITask task2) {
-        return getEquality(task1, task2, null);
-    }
-
-    /* (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) {
-        TaskEquality equality = getEquality(instance1, instance2, TaskEquality.LEXICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL));
-    }
-
-    /* (non-Javadoc)
-     * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance, ITaskInstance)
-     */
-    @Override
-    public boolean areSyntacticallyEqual(ITaskInstance instance1, ITaskInstance instance2) {
-        TaskEquality equality = getEquality(instance1, instance2, TaskEquality.SYNTACTICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL));
-    }
-
-    /* (non-Javadoc)
-     * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance, ITaskInstance)
-     */
-    @Override
-    public boolean areSemanticallyEqual(ITaskInstance instance1, ITaskInstance instance2) {
-        TaskEquality equality = getEquality(instance1, instance2, TaskEquality.SEMANTICALLY_EQUAL);
-        return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL));
-    }
-
-    /* (non-Javadoc)
-     * @see TaskComparisonRule#compare(ITaskInstance, ITaskInstance)
-     */
-    @Override
-    public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2) {
-        return getEquality(instance1, instance2, null);
-    }
-
-    /**
-     * <p>
-     * compares two selections with each other checking for the provided required level of
-     * equality. If this level is ensured, the method immediately returns. The more concrete
-     * the required equality level, the more checks this method performs.
-     * </p>
-     * 
-     * @param task1                 the first task to be compared
-     * @param task2                 the second task to be compared
-     * @param requiredEqualityLevel the equality level to be checked for
-     * 
-     * @return the determined equality.
-     */
-    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 TaskEquality.LEXICALLY_EQUAL;
-        }
-        else if ((children1.size() == 0) || (children2.size() == 0)) {
-            return TaskEquality.UNEQUAL;
-        }
-
-        if (requiredEqualityLevel == null) {
-            // calculate the common equality level for all children of both selections.
-            // do it in both directions to ensure commutative comparison
-            return getMostConcreteEqualityLevel(children1, children2);
-        }
-        else {
-            // we are searching for a specific equality
-            if (checkEqualityLevel(children1, children2, requiredEqualityLevel)) {
-                return requiredEqualityLevel;
-            }
-            else {
-                return TaskEquality.UNEQUAL;
-            }
-        }
-    }
-
-    /**
-     * <p>
-     * determines the most concrete equality level for all tasks in the first list compared to all
-     * tasks in the second list. It is sufficient, if there is one task in one list for which there
-     * exist an equal task in the other list.
-     * </p>
-     *
-     * @param children1 the first list to be compared
-     * @param children2 the second list to be compared
-     * 
-     * @return the most concrete task equality identified for all tasks in the first list with
-     *         respect to the second list
-     */
-    private TaskEquality getMostConcreteEqualityLevel(List<ITask> children1, List<ITask> children2)
-    {
-        TaskEquality childEquality;
-        TaskEquality currentEquality;
-        for (ITask child1 : children1) {
-            childEquality = null;
-            for (ITask child2 : children2) {
-                currentEquality = callRuleManager(child1, child2, null);
-                if ((currentEquality != null) && (currentEquality != TaskEquality.UNEQUAL)) {
-                    if (childEquality == null) {
-                        childEquality = currentEquality;
-                    }
-                    else {
-                        childEquality = childEquality.getCommonDenominator(currentEquality);
-                    }
-                    
-                    if (childEquality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)) {
-                        // as we calculate the most concrete equality, we can break up here
-                        return TaskEquality.LEXICALLY_EQUAL;
-                    }
-                }
-            }
-        }
-
-        // as the comparison should be commutative, we do not need to check, if in list 2 there is
-        // a child equal to one in list 1
-        return TaskEquality.UNEQUAL;
-    }
-
-    /**
-     * <p>
-     * ensures for the two given lists, that for at least one task in the first list there is a task
-     * in the second list being on the given level equal to the task in the first list.
-     * </p> 
-     * 
-     * @param children1             the first list to be compared
-     * @param children2             the second list to be compared
-     * @param requiredEqualityLevel the equality level to be checked for
-     * 
-     * @return true if there is a task in the first list that has an equal task in the second list
-     *         when considering the given equality level, false else.
-     */
-    private boolean checkEqualityLevel(List<ITask>  children1,
-                                       List<ITask>  children2,
-                                       TaskEquality requiredEqualityLevel)
-    {
-        TaskEquality currentEquality;
-        for (ITask child1 : children1) {
-            for (ITask child2 : children2) {
-                currentEquality = callRuleManager(child1, child2, requiredEqualityLevel);
-                if ((currentEquality != null) && (currentEquality.isAtLeast(requiredEqualityLevel)))
-                {
-                    // we found at least one equal child with sufficient equality in the
-                    // second list. So be can break up for this child.
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * <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 child1                the first task to be compared
-     * @param child2                the second task to be compared
-     * @param requiredEqualityLevel the equality level to be checked for
-     * 
-     * @return the determined equality
-     */
-    private TaskEquality callRuleManager(ITask        child1,
-                                         ITask        child2,
-                                         TaskEquality requiredEqualityLevel)
-    {
-        if (requiredEqualityLevel == null) {
-            return TaskEqualityRuleManager.getInstance().compare(child1, child2);
-        }
-        else if (TaskEqualityRuleManager.getInstance().areAtLeastEqual
-                     (child1, child2, requiredEqualityLevel))
-        {
-            return requiredEqualityLevel;
-        }
-        else {
-            return TaskEquality.UNEQUAL;
-        }
-    }
-
-    /**
-     * <p>
-     * compares two selection instances with each other checking for the provided required level of
-     * equality. If this level is ensured, the method immediately returns. The more concrete
-     * the required equality level, the more checks this method performs.
-     * </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 getEquality(ITaskInstance taskInstance1,
-                                     ITaskInstance taskInstance2,
-                                     TaskEquality  requiredEqualityLevel)
-    {
-        ITaskInstance child1 = ((ISelectionInstance) taskInstance1).getChild();
-        ITaskInstance child2 = ((ISelectionInstance) taskInstance2).getChild();
-
-        // if both selections do not have children, they are lexically equal. If only one of them
-        // has children, they are unequal.
-        if ((child1 == null) && (child2 == null)) {
-            return TaskEquality.LEXICALLY_EQUAL;
-        }
-        else if ((child1 == null) || (child2 == null)) {
-            return TaskEquality.UNEQUAL;
-        }
-
-        TaskEquality equality = callRuleManager(child1, child2, requiredEqualityLevel);
-        
-        if (equality == TaskEquality.IDENTICAL) {
-            // two different selection instances can be at most lexically equal even if their
-            // children are identical
-            return TaskEquality.LEXICALLY_EQUAL;
-        }
-        else {
-            return equality;
-        }
-    }
-
-    /**
-     * <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;
-        }
-    }
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#areLexicallyEqual(ITask, ITask)
+	 */
+	@Override
+	public boolean areLexicallyEqual(ITask task1, ITask task2) {
+		final TaskEquality equality = getEquality(task1, task2,
+				TaskEquality.LEXICALLY_EQUAL);
+		return (equality != null)
+				&& (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#areLexicallyEqual(ITaskInstance, ITaskInstance)
+	 */
+	@Override
+	public boolean areLexicallyEqual(ITaskInstance instance1,
+			ITaskInstance instance2) {
+		final TaskEquality equality = getEquality(instance1, instance2,
+				TaskEquality.LEXICALLY_EQUAL);
+		return (equality != null)
+				&& (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#areSemanticallyEqual(ITask, ITask)
+	 */
+	@Override
+	public boolean areSemanticallyEqual(ITask task1, ITask task2) {
+		final TaskEquality equality = getEquality(task1, task2,
+				TaskEquality.SEMANTICALLY_EQUAL);
+		return (equality != null)
+				&& (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance,
+	 * ITaskInstance)
+	 */
+	@Override
+	public boolean areSemanticallyEqual(ITaskInstance instance1,
+			ITaskInstance instance2) {
+		final TaskEquality equality = getEquality(instance1, instance2,
+				TaskEquality.SEMANTICALLY_EQUAL);
+		return (equality != null)
+				&& (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#areSyntacticallyEqual(ITask, ITask)
+	 */
+	@Override
+	public boolean areSyntacticallyEqual(ITask task1, ITask task2) {
+		final TaskEquality equality = getEquality(task1, task2,
+				TaskEquality.SYNTACTICALLY_EQUAL);
+		return (equality != null)
+				&& (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance,
+	 * ITaskInstance)
+	 */
+	@Override
+	public boolean areSyntacticallyEqual(ITaskInstance instance1,
+			ITaskInstance instance2) {
+		final TaskEquality equality = getEquality(instance1, instance2,
+				TaskEquality.SYNTACTICALLY_EQUAL);
+		return (equality != null)
+				&& (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL));
+	}
+
+	/**
+	 * <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 child1
+	 *            the first task to be compared
+	 * @param child2
+	 *            the second task to be compared
+	 * @param requiredEqualityLevel
+	 *            the equality level to be checked for
+	 * 
+	 * @return the determined equality
+	 */
+	private TaskEquality callRuleManager(ITask child1, ITask child2,
+			TaskEquality requiredEqualityLevel) {
+		if (requiredEqualityLevel == null) {
+			return TaskEqualityRuleManager.getInstance()
+					.compare(child1, child2);
+		} else if (TaskEqualityRuleManager.getInstance().areAtLeastEqual(
+				child1, child2, requiredEqualityLevel)) {
+			return requiredEqualityLevel;
+		} else {
+			return TaskEquality.UNEQUAL;
+		}
+	}
+
+	/**
+	 * <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;
+		}
+	}
+
+	/**
+	 * <p>
+	 * ensures for the two given lists, that for at least one task in the first
+	 * list there is a task in the second list being on the given level equal to
+	 * the task in the first list.
+	 * </p>
+	 * 
+	 * @param children1
+	 *            the first list to be compared
+	 * @param children2
+	 *            the second list to be compared
+	 * @param requiredEqualityLevel
+	 *            the equality level to be checked for
+	 * 
+	 * @return true if there is a task in the first list that has an equal task
+	 *         in the second list when considering the given equality level,
+	 *         false else.
+	 */
+	private boolean checkEqualityLevel(List<ITask> children1,
+			List<ITask> children2, TaskEquality requiredEqualityLevel) {
+		TaskEquality currentEquality;
+		for (final ITask child1 : children1) {
+			for (final ITask child2 : children2) {
+				currentEquality = callRuleManager(child1, child2,
+						requiredEqualityLevel);
+				if ((currentEquality != null)
+						&& (currentEquality.isAtLeast(requiredEqualityLevel))) {
+					// we found at least one equal child with sufficient
+					// equality in the
+					// second list. So be can break up for this child.
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#compare(ITask, ITask)
+	 */
+	@Override
+	public TaskEquality compare(ITask task1, ITask task2) {
+		return getEquality(task1, task2, null);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#compare(ITaskInstance, ITaskInstance)
+	 */
+	@Override
+	public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2) {
+		return getEquality(instance1, instance2, null);
+	}
+
+	/**
+	 * <p>
+	 * compares two selections with each other checking for the provided
+	 * required level of equality. If this level is ensured, the method
+	 * immediately returns. The more concrete the required equality level, the
+	 * more checks this method performs.
+	 * </p>
+	 * 
+	 * @param task1
+	 *            the first task to be compared
+	 * @param task2
+	 *            the second task to be compared
+	 * @param requiredEqualityLevel
+	 *            the equality level to be checked for
+	 * 
+	 * @return the determined equality.
+	 */
+	private TaskEquality getEquality(ITask task1, ITask task2,
+			TaskEquality requiredEqualityLevel) {
+		final List<ITask> children1 = ((ISelection) task1).getChildren();
+		final 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 TaskEquality.LEXICALLY_EQUAL;
+		} else if ((children1.size() == 0) || (children2.size() == 0)) {
+			return TaskEquality.UNEQUAL;
+		}
+
+		if (requiredEqualityLevel == null) {
+			// calculate the common equality level for all children of both
+			// selections.
+			// do it in both directions to ensure commutative comparison
+			return getMostConcreteEqualityLevel(children1, children2);
+		} else {
+			// we are searching for a specific equality
+			if (checkEqualityLevel(children1, children2, requiredEqualityLevel)) {
+				return requiredEqualityLevel;
+			} else {
+				return TaskEquality.UNEQUAL;
+			}
+		}
+	}
+
+	/**
+	 * <p>
+	 * compares two selection instances with each other checking for the
+	 * provided required level of equality. If this level is ensured, the method
+	 * immediately returns. The more concrete the required equality level, the
+	 * more checks this method performs.
+	 * </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 getEquality(ITaskInstance taskInstance1,
+			ITaskInstance taskInstance2, TaskEquality requiredEqualityLevel) {
+		final ITaskInstance child1 = ((ISelectionInstance) taskInstance1)
+				.getChild();
+		final ITaskInstance child2 = ((ISelectionInstance) taskInstance2)
+				.getChild();
+
+		// if both selections do not have children, they are lexically equal. If
+		// only one of them
+		// has children, they are unequal.
+		if ((child1 == null) && (child2 == null)) {
+			return TaskEquality.LEXICALLY_EQUAL;
+		} else if ((child1 == null) || (child2 == null)) {
+			return TaskEquality.UNEQUAL;
+		}
+
+		final TaskEquality equality = callRuleManager(child1, child2,
+				requiredEqualityLevel);
+
+		if (equality == TaskEquality.IDENTICAL) {
+			// two different selection instances can be at most lexically equal
+			// even if their
+			// children are identical
+			return TaskEquality.LEXICALLY_EQUAL;
+		} else {
+			return equality;
+		}
+	}
+
+	/**
+	 * <p>
+	 * determines the most concrete equality level for all tasks in the first
+	 * list compared to all tasks in the second list. It is sufficient, if there
+	 * is one task in one list for which there exist an equal task in the other
+	 * list.
+	 * </p>
+	 *
+	 * @param children1
+	 *            the first list to be compared
+	 * @param children2
+	 *            the second list to be compared
+	 * 
+	 * @return the most concrete task equality identified for all tasks in the
+	 *         first list with respect to the second list
+	 */
+	private TaskEquality getMostConcreteEqualityLevel(List<ITask> children1,
+			List<ITask> children2) {
+		TaskEquality childEquality;
+		TaskEquality currentEquality;
+		for (final ITask child1 : children1) {
+			childEquality = null;
+			for (final ITask child2 : children2) {
+				currentEquality = callRuleManager(child1, child2, null);
+				if ((currentEquality != null)
+						&& (currentEquality != TaskEquality.UNEQUAL)) {
+					if (childEquality == null) {
+						childEquality = currentEquality;
+					} else {
+						childEquality = childEquality
+								.getCommonDenominator(currentEquality);
+					}
+
+					if (childEquality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)) {
+						// as we calculate the most concrete equality, we can
+						// break up here
+						return TaskEquality.LEXICALLY_EQUAL;
+					}
+				}
+			}
+		}
+
+		// as the comparison should be commutative, we do not need to check, if
+		// in list 2 there is
+		// a child equal to one in list 1
+		return TaskEquality.UNEQUAL;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#isApplicable(ITask, ITask)
+	 */
+	@Override
+	public boolean isApplicable(ITask task1, ITask task2) {
+		return (task1 instanceof ISelection) && (task2 instanceof ISelection);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see TaskComparisonRule#isApplicable(ITaskInstance, ITaskInstance)
+	 */
+	@Override
+	public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2) {
+		return isApplicable(instance1.getTask(), instance2.getTask());
+	}
 }
