Index: branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskComparisonRule.java
===================================================================
--- branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskComparisonRule.java	(revision 1646)
+++ branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskComparisonRule.java	(revision 1733)
@@ -20,6 +20,7 @@
 /**
  * <p>
- * A task comparison rule is used by the {@link TaskEqualityRuleManager} to compare tasks and
- * task instances with each other. It provides several methods to be called for a comparison.
+ * A task comparison rule is used by the {@link TaskEqualityRuleManager} to
+ * compare tasks and task instances with each other. It provides several methods
+ * to be called for a comparison.
  * </p>
  * 
@@ -29,127 +30,151 @@
 public interface TaskComparisonRule {
 
-    /**
-     * <p>
-     * checks if the rule is applicable for comparing the two provided tasks
-     * </p>
-     * 
-     * @param task1 the first task to compare
-     * @param task2 the second task to compare
-     * 
-     * @return true, if the rule is applicable, false else
-     */
-    public boolean isApplicable(ITask task1, ITask task2);
+	/**
+	 * <p>
+	 * checks, if the provided tasks are lexically equal
+	 * </p>
+	 * 
+	 * @param task1
+	 *            the first task to compare
+	 * @param task2
+	 *            the second task to compare
+	 * 
+	 * @return true, if the tasks are equal, false else
+	 */
+	public boolean areLexicallyEqual(ITask task1, ITask task2);
 
-    /**
-     * <p>
-     * checks, if the provided tasks are lexically equal
-     * </p>
-     * 
-     * @param task1 the first task to compare
-     * @param task2 the second task to compare
-     * 
-     * @return true, if the tasks are equal, false else
-     */
-    public boolean areLexicallyEqual(ITask task1, ITask task2);
+	/**
+	 * <p>
+	 * checks, if the provided task instances are lexically equal
+	 * </p>
+	 * 
+	 * @param instance1
+	 *            the first task instance to compare
+	 * @param instance2
+	 *            the second task instance to compare
+	 * 
+	 * @return true, if the tasks are equal, false else
+	 */
+	public boolean areLexicallyEqual(ITaskInstance instance1,
+			ITaskInstance instance2);
 
-    /**
-     * <p>
-     * checks, if the provided tasks are syntactically equal
-     * </p>
-     * 
-     * @param task1 the first task to compare
-     * @param task2 the second task to compare
-     * 
-     * @return true, if the tasks are equal, false else
-     */
-    public boolean areSyntacticallyEqual(ITask task1, ITask task2);
+	/**
+	 * <p>
+	 * checks, if the provided tasks are semantically equal
+	 * </p>
+	 * 
+	 * @param task1
+	 *            the first task to compare
+	 * @param task2
+	 *            the second task to compare
+	 * 
+	 * @return true, if the tasks are equal, false else
+	 */
+	public boolean areSemanticallyEqual(ITask task1, ITask task2);
 
-    /**
-     * <p>
-     * checks, if the provided tasks are semantically equal
-     * </p>
-     * 
-     * @param task1 the first task to compare
-     * @param task2 the second task to compare
-     * 
-     * @return true, if the tasks are equal, false else
-     */
-    public boolean areSemanticallyEqual(ITask task1, ITask task2);
+	/**
+	 * <p>
+	 * checks, if the provided task instances are semantically equal
+	 * </p>
+	 * 
+	 * @param instance1
+	 *            the first task instance to compare
+	 * @param instance2
+	 *            the second task instance to compare
+	 * 
+	 * @return true, if the tasks are equal, false else
+	 */
+	public boolean areSemanticallyEqual(ITaskInstance instance1,
+			ITaskInstance instance2);
 
-    /**
-     * <p>
-     * compares two tasks with each other. The result of the method is either a task equality or
-     * null. If it is null, it means, that the rule is not able to correctly compare the two given
-     * tasks
-     * </p>
-     * 
-     * @param task1 the first task to compare
-     * @param task2 the second task to compare
-     * 
-     * @return as described
-     */
-    public TaskEquality compare(ITask task1, ITask task2);
+	/**
+	 * <p>
+	 * checks, if the provided tasks are syntactically equal
+	 * </p>
+	 * 
+	 * @param task1
+	 *            the first task to compare
+	 * @param task2
+	 *            the second task to compare
+	 * 
+	 * @return true, if the tasks are equal, false else
+	 */
+	public boolean areSyntacticallyEqual(ITask task1, ITask task2);
 
-    /**
-     * <p>
-     * checks if the rule is applicable for comparing the two provided task instances
-     * </p>
-     * 
-     * @param instance1 the first task instance to compare
-     * @param instance2 the second task instance to compare
-     * 
-     * @return true, if the rule is applicable, false else
-     */
-    public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2);
+	/**
+	 * <p>
+	 * checks, if the provided task instances are syntactically equal
+	 * </p>
+	 * 
+	 * @param instance1
+	 *            the first task instance to compare
+	 * @param instance2
+	 *            the second task instance to compare
+	 * 
+	 * @return true, if the tasks are equal, false else
+	 */
+	public boolean areSyntacticallyEqual(ITaskInstance instance1,
+			ITaskInstance instance2);
 
-    /**
-     * <p>
-     * checks, if the provided task instances are lexically equal
-     * </p>
-     * 
-     * @param instance1 the first task instance to compare
-     * @param instance2 the second task instance to compare
-     * 
-     * @return true, if the tasks are equal, false else
-     */
-    public boolean areLexicallyEqual(ITaskInstance instance1, ITaskInstance instance2);
+	/**
+	 * <p>
+	 * compares two tasks with each other. The result of the method is either a
+	 * task equality or null. If it is null, it means, that the rule is not able
+	 * to correctly compare the two given tasks
+	 * </p>
+	 * 
+	 * @param task1
+	 *            the first task to compare
+	 * @param task2
+	 *            the second task to compare
+	 * 
+	 * @return as described
+	 */
+	public TaskEquality compare(ITask task1, ITask task2);
 
-    /**
-     * <p>
-     * checks, if the provided task instances are syntactically equal
-     * </p>
-     * 
-     * @param instance1 the first task instance to compare
-     * @param instance2 the second task instance to compare
-     * 
-     * @return true, if the tasks are equal, false else
-     */
-    public boolean areSyntacticallyEqual(ITaskInstance instance1, ITaskInstance instance2);
+	/**
+	 * <p>
+	 * compares two task instances with each other. The result of the method is
+	 * either a task instance equality or null. If it is null, it means, that
+	 * the rule is not able to correctly compare the two given task instances
+	 * </p>
+	 * 
+	 * @param instance1
+	 *            the first task instance to compare
+	 * @param instance2
+	 *            the second task instance to compare
+	 * 
+	 * @return as described
+	 */
+	public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2);
 
-    /**
-     * <p>
-     * checks, if the provided task instances are semantically equal
-     * </p>
-     * 
-     * @param instance1 the first task instance to compare
-     * @param instance2 the second task instance to compare
-     * 
-     * @return true, if the tasks are equal, false else
-     */
-    public boolean areSemanticallyEqual(ITaskInstance instance1, ITaskInstance instance2);
+	/**
+	 * <p>
+	 * checks if the rule is applicable for comparing the two provided tasks
+	 * </p>
+	 * 
+	 * @param task1
+	 *            the first task to compare
+	 * @param task2
+	 *            the second task to compare
+	 * 
+	 * @return true, if the rule is applicable, false else
+	 */
+	public boolean isApplicable(ITask task1, ITask task2);
 
-    /**
-     * <p>
-     * compares two task instances with each other. The result of the method is either a task
-     * instance equality or null. If it is null, it means, that the rule is not able to correctly
-     * compare the two given task instances
-     * </p>
-     * 
-     * @param instance1 the first task instance to compare
-     * @param instance2 the second task instance to compare
-     * 
-     * @return as described
-     */
-    public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2);
+	/**
+	 * <p>
+	 * checks if the rule is applicable for comparing the two provided task
+	 * instances
+	 * </p>
+	 * 
+	 * @param instance1
+	 *            the first task instance to compare
+	 * @param instance2
+	 *            the second task instance to compare
+	 * 
+	 * @return true, if the rule is applicable, false else
+	 */
+	public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2);
 
 }
