source: branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRule.java

//   Copyright 2012 Georg-August-Universität Göttingen, Germany
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

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.ISelectionInstance;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;

// TODO: Auto-generated Javadoc
/**
 * <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.
 * </p>
 *
 * @author 2012, last modified by $Author: patrick$
 * @version $Revision: $ $Date: 19.02.2012$
 */
public class SelectionComparisonRule implements TaskComparisonRule {

        /*
         * (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());
        }
}