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

//   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.IIteration;
import de.ugoe.cs.autoquest.tasktrees.treeifc.IIterationInstance;
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.IStructuringTemporalRelationship;
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>
         * counter for generating unique ids. Starts at 0 for each new program start
         * </p>
         */
        private static int idCounter = 0;

        public static int missedOptionals = 0;
        
        /**
         * <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) {
                ISequenceInstance subsequence = taskFactory
                                .createNewTaskInstance(model);

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

                return subsequence;
        }

        /**
         * <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
         * @throws  
         */
        static ISequenceInstance createNewSubSequenceInRange(
                        ITaskInstanceList parent, int startIndex, int endIndex,
                        ISequence model, ITaskFactory taskFactory, ITaskBuilder taskBuilder)   {
                ISequenceInstance subsequence = taskFactory
                                .createNewTaskInstance(model);
                
                // TODO: Debug output
                                System.out.println("PRINTING MODEL: ");
                                for (int i = 0; i < subsequence.getSequence().getChildren().size(); i++) {
                                        System.out.println(subsequence.getSequence().getChildren().get(i));

                                        if (subsequence.getSequence().getChildren().get(i).getType() == "selection") {
                                                for (int j = 0; j < ((ISelection) subsequence.getSequence().getChildren().get(i))
                                                                .getChildren().size(); j++) {
                                                        if(((IStructuringTemporalRelationship) subsequence.getSequence().getChildren().get(i)).getChildren().get(j).getType() =="sequence")
                                                        {
                                                                ISequence foo =  (ISequence) ((ISelection) (subsequence.getSequence().getChildren().get(i))).getChildren().get(j);
                                                                System.out.println("\t" + foo);
                                                                for(int k=0; k< foo.getChildren().size();k++) {
                                                                        System.out.println("\t\t" +foo.getChildren().get(k));
                                                                }
                                                                System.out.println();
                                                        }
                                                        else{
                                                                System.out.println("\t"
                                                                                + ((ISelection) subsequence.getSequence().getChildren().get(i))
                                                                                                .getChildren().get(j));
                                                        }
                                                
                                                }
                                        }
                                
                                }
                                System.out.println();
                
                //TODO: This is dirty!
                missedOptionals=0;
                int modelindex=0;
                for (int i = startIndex; i <= endIndex; i++) {
                        
                        if(modelindex == model.getChildren().size()) {
                                break;
                        }
                        ITask tempTask = model.getChildren().get(modelindex);
                        //System.out.println("Trying to add " + parent.get(startIndex)
                        //      + " to the model instance " + tempTask.getType());
                        if (tempTask.getType() == "optionality") {
                                                
                                        if(((IMarkingTemporalRelationship) tempTask).getMarkedTask() == parent.get(startIndex).getTask()) {
                                                System.out.println("Adding OptionalInstance " + parent.get(startIndex) + " to " + tempTask.getType());
                                                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");
                                                IOptionalInstance optional = taskFactory.createNewTaskInstance((IOptional) tempTask);
                                                taskBuilder.addChild(subsequence, optional);
                                                modelindex++;
                                                missedOptionals++;
                                                continue;
                                        }                               
                        } else if (tempTask.getType() == "selection") {
                                
                                ISelectionInstance selection = taskFactory.createNewTaskInstance((ISelection) tempTask);
                                ISelection tmpSel = (ISelection)tempTask;
                                if(tmpSel.getChildren().get(0).getType() == "sequence" && tmpSel.getChildren().get(1).getType()=="sequence") {
                                        System.out.println("Adding SequenceInstance " + parent.get(startIndex) + " to " + tempTask);
                                        ISequenceInstance selseq = null;
                                        System.out.println("IDS: " + parent.get(startIndex).getTask().getId() + " " +((ISequence)tmpSel.getChildren().get(0)).getChildren().get(0).getId());
                                        System.out.println("IDS: " + parent.get(startIndex).getTask().getId() + " " +((ISequence)tmpSel.getChildren().get(1)).getChildren().get(0).getId());
                                        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 {
                                                //throw new Exception("Error while creating subsequence of a selection");
                                                
                                                System.out.println("Error while creating subsequence of a selection");
                                        }
                                        
                                        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);
                                }
                                else
                                {
                                        System.out.println("Adding SelectionInstance " + parent.get(startIndex) + " to " + tempTask);
                                        taskBuilder.setChild(selection, parent.get(startIndex));
                                }
                                taskBuilder.addChild(subsequence,selection);

                        } else if (tempTask.getType() == "sequence") {
                                System.out.println("Adding SequenceInstance " + parent.get(startIndex) + " to " + tempTask);
                                ISequenceInstance sequence = taskFactory.createNewTaskInstance((ISequence) tempTask);
                                taskBuilder.addChild(sequence, parent.get(i));
                                taskBuilder.addChild(subsequence,sequence);
                                //taskBuilder.addChild(subsequence, parent.get(startIndex));
                        } else if (tempTask.getType() == "iteration") {
                                System.out.println("Adding IterationInstance " + parent.get(startIndex) + " to " + tempTask);
                                taskBuilder.addChild(subsequence, parent.get(startIndex));
                        } else {
                                System.out.println("Adding EventInstance " + parent.get(startIndex) + " to " + tempTask);
                                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>
         * prevent instantiation
         * </p>
         */
        private RuleUtils() {
                // prevent instantiation
        }

}