source: branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleUtils.java @ 1735

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

import de.ugoe.cs.autoquest.tasktrees.treeifc.IMarkingTemporalRelationship;
import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional;
import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptionalInstance;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelectionInstance;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequenceInstance;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;


/**
 * <p>
 * provides some convenience methods for rule application
 * </p>.
 *
 * @author Patrick Harms
 */
class RuleUtils {

        /**
         * <p>
         * replaces a sub sequence for a specified range of elements in the provided
         * task instances list by a sub task instance
         * </p>.
         *
         * @param parent            the list of which the range shall be replaced
         * @param startIndex            the start index of the range
         * @param endIndex            the end index of the range (inclusive)
         * @param model            the task model (required for instantiating the sub sequence)
         * @param taskFactory            the task factory used for instantiating the sub sequence
         * @param taskBuilder            the task builder to perform changes in the task structure
         * @return the replacement for the range
         */
        static ISequenceInstance createNewSubSequenceInRange(
                        ITaskInstanceList parent, int startIndex, int endIndex,
                        ISequence model, ITaskFactory taskFactory, ITaskBuilder taskBuilder) {
                final ISequenceInstance subsequence = taskFactory
                                .createNewTaskInstance(model);

                
                // TODO: This is dirty, return this in addition with the sequence instance instead
                missedOptionals = 0;
                int modelindex = 0;
                for (int i = startIndex; i <= endIndex; i++) {

                        if (modelindex == model.getChildren().size()) {
                                break;
                        }
                        final ITask tempTask = model.getChildren().get(modelindex);
                        // System.out.println("Trying to add " + parent.get(startIndex)
                        // + " to the model instance " + tempTask);
                        if (tempTask.getType() == "optionality") {

                                if (((IMarkingTemporalRelationship) tempTask).getMarkedTask() == parent
                                                .get(startIndex).getTask()) {
                                        // System.out.println("Adding OptionalInstance " +
                                        // parent.get(startIndex) + " to " + tempTask.getType());
                                        final IOptionalInstance optional = taskFactory
                                                        .createNewTaskInstance((IOptional) tempTask);
                                        taskBuilder.setChild(optional, parent.get(startIndex));
                                        taskBuilder.addChild(subsequence, optional);
                                } else {
                                        // System.out.println("Adding Empty optional, not deleting anything from the input sequence");
                                        final IOptionalInstance optional = taskFactory
                                                        .createNewTaskInstance((IOptional) tempTask);
                                        taskBuilder.addChild(subsequence, optional);
                                        modelindex++;
                                        missedOptionals++;
                                        continue;
                                }
                        } else if (tempTask.getType() == "selection") {
                                final ISelectionInstance selection = taskFactory
                                                .createNewTaskInstance((ISelection) tempTask);
                                final ISelection tmpSel = (ISelection) tempTask;
                                if ((tmpSel.getChildren().get(0).getType() == "sequence")
                                                && (tmpSel.getChildren().get(1).getType() == "sequence")) {
                                        ISequenceInstance selseq = null;
                                        // The selection I create can just have 2 children
                                        if (parent.get(startIndex).getTask().getId() == ((ISequence) tmpSel
                                                        .getChildren().get(0)).getChildren().get(0).getId()) {
                                                selseq = taskFactory
                                                                .createNewTaskInstance((ISequence) tmpSel
                                                                                .getChildren().get(0));
                                        } else if (parent.get(startIndex).getTask().getId() == ((ISequence) tmpSel
                                                        .getChildren().get(1)).getChildren().get(0).getId()) {
                                                selseq = taskFactory
                                                                .createNewTaskInstance((ISequence) tmpSel
                                                                                .getChildren().get(1));
                                        } else if ((parent.get(startIndex).getTask().getId() == tmpSel
                                                        .getChildren().get(0).getId())
                                                        || (parent.get(startIndex).getTask().getId() == tmpSel
                                                                        .getChildren().get(1).getId())) {
                                                continue;
                                        }

                                        for (int k = 0; k < selseq.getSequence().getChildren()
                                                        .size(); k++) {
                                                taskBuilder.addChild(selseq, parent.get(startIndex));
                                                taskBuilder.removeTaskInstance(parent, startIndex);
                                                i++;
                                        }
                                        taskBuilder.setChild(selection, selseq);
                                        taskBuilder.addChild(subsequence, selection);
                                        modelindex++;
                                        continue;
                                } else {
                                        taskBuilder.setChild(selection, parent.get(startIndex));
                                        taskBuilder.addChild(subsequence, selection);
                                }
                        } else if (tempTask.getType() == "sequence") {
                                taskBuilder.addChild(subsequence, parent.get(startIndex));
                        } else if (tempTask.getType() == "iteration") {
                                taskBuilder.addChild(subsequence, parent.get(startIndex));
                        } else {
                                taskBuilder.addChild(subsequence, parent.get(startIndex));
                        }
                        taskBuilder.removeTaskInstance(parent, startIndex);
                        modelindex++;
                }

                taskBuilder.addTaskInstance(parent, startIndex, subsequence);

                return subsequence;
        }

        /**
         * <p>
         * returns the next available id (uses the id counter)
         * </p>.
         *
         * @return the next available id
         */
        static synchronized String getNewId() {
                return Integer.toString(idCounter++);
        }

        /**
         * <p>
         * generates a sub sequence for a specified range of elements in the
         * provided task instances list.
         * </p>
         *
         * @param parent
         *            the list of which the range shall be extracted
         * @param startIndex
         *            the start index of the range
         * @param endIndex
         *            the end index of the range (inclusive)
         * @param model
         *            the task model (required for instantiating the sub sequence)
         * @param taskFactory
         *            the task factory used for instantiating the sub sequence
         * @param taskBuilder
         *            the task builder to perform changes in the task structure
         * 
         * @return a task instance representing the requested sub sequence
         */
        static ITaskInstance getSubSequenceInRange(ITaskInstanceList parent,
                        int startIndex, int endIndex, ISequence model,
                        ITaskFactory taskFactory, ITaskBuilder taskBuilder) {
                final ISequenceInstance subsequence = taskFactory
                                .createNewTaskInstance(model);

                for (int i = startIndex; i <= endIndex; i++) {
                        taskBuilder.addChild(subsequence, parent.get(i));
                }

                return subsequence;
        }

        /**
         * Prints the progress percentage.
         *
         * @param message the message
         * @param count the count
         * @param size the size
         */
        static void printProgressPercentage(String message, int count, int size) {
                if (size > 100) {
                        if (((count % (size / 100)) == 0)) {
                                // Console.traceln(Level.INFO,("Thread" +
                                // Thread.currentThread().getName() + ": " + Math.round((float)
                                // count/size*100))+ "%");
                                System.out.println(message + " in thread"
                                                + Thread.currentThread().getName() + ": "
                                                + Math.round(((float) count / size) * 100) + "%");
                        }
                } else {
                        // Console.traceln(Level.INFO,("Thread" +
                        // Thread.currentThread().getName() + ": " +Math.round((float)
                        // count/size*100))+ "%");
                        System.out.println(message + " in thread"
                                        + Thread.currentThread().getName() + ": "
                                        + Math.round(((float) count / size) * 100) + "%");

                }
        }

        /**
         * <p>
         * counter for generating unique ids. Starts at 0 for each new program start
         * </p>
         */
        private static int idCounter = 0;

        /** The missed optionals. */
        public static int missedOptionals = 0;

        /**
         * <p>
         * prevent instantiation
         * </p>.
         */
        private RuleUtils() {
                // prevent instantiation
        }

}