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

//   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.Collection;

import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;

// TODO: Auto-generated Javadoc
/**
 * <p>
 * This rule identifies two tasks as lexically equal, if they are both event
 * tasks and if their respective event types and targets equal.
 * </p>
 * 
 * @author Patrick Harms
 */
public class EventTaskComparisonRule implements TaskComparisonRule {

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#areLexicallyEqual(ITask, ITask)
         */
        @Override
        public boolean areLexicallyEqual(ITask task1, ITask task2) {
                final Collection<ITaskInstance> taskInstances1 = task1.getInstances();
                final Collection<ITaskInstance> taskInstances2 = task2.getInstances();

                for (final ITaskInstance instance1 : taskInstances1) {
                        boolean found = false;

                        for (final ITaskInstance instance2 : taskInstances2) {
                                if (areLexicallyEqual(instance1, instance2)) {
                                        found = true;
                                        break;
                                }
                        }

                        if (!found) {
                                return false;
                        }
                }

                return true;
        }

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#areLexicallyEqual(ITaskInstance, ITaskInstance)
         */
        @Override
        public boolean areLexicallyEqual(ITaskInstance instance1,
                        ITaskInstance instance2) {
                final IEventTaskInstance eventTask1 = (IEventTaskInstance) instance1;
                final IEventTaskInstance eventTask2 = (IEventTaskInstance) instance2;

                return (eventTask1.getEvent().getType()
                                .equals(eventTask2.getEvent().getType()) && eventTask1
                                .getEvent().getTarget()
                                .equals(eventTask2.getEvent().getTarget()));
        }

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#areSemanticallyEqual(ITask, ITask)
         */
        @Override
        public boolean areSemanticallyEqual(ITask task1, ITask task2) {
                return areLexicallyEqual(task1, task2);
        }

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance,
         * ITaskInstance)
         */
        @Override
        public boolean areSemanticallyEqual(ITaskInstance instance1,
                        ITaskInstance instance2) {
                return areLexicallyEqual(instance1, instance2);
        }

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#areSyntacticallyEqual(ITask, ITask)
         */
        @Override
        public boolean areSyntacticallyEqual(ITask task1, ITask task2) {
                return areLexicallyEqual(task1, task2);
        }

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance,
         * ITaskInstance)
         */
        @Override
        public boolean areSyntacticallyEqual(ITaskInstance instance1,
                        ITaskInstance instance2) {
                return areLexicallyEqual(instance1, instance2);
        }

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#compare(ITask, ITask)
         */
        @Override
        public TaskEquality compare(ITask task1, ITask task2) {
                if (areLexicallyEqual(task1, task2)) {
                        return TaskEquality.LEXICALLY_EQUAL;
                } else {
                        return TaskEquality.UNEQUAL;
                }
        }

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

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#isApplicable(ITask, ITask)
         */
        @Override
        public boolean isApplicable(ITask task1, ITask task2) {
                return (task1 instanceof IEventTask) && (task2 instanceof IEventTask);
        }

        /*
         * (non-Javadoc)
         * 
         * @see TaskComparisonRule#isApplicable(ITaskInstance, ITaskInstance)
         */
        @Override
        public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2) {
                return (instance1 instanceof IEventTaskInstance)
                                && (instance2 instanceof IEventTaskInstance);
        }

}