Changeset 1976 for trunk


Ignore:
Timestamp:
06/24/15 11:29:20 (9 years ago)
Author:
pharms
Message:
  • corrected harmonizing optionals
  • corrected handling of integrate optional flatten instructions to not cover other instructions
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/CondenseSimilarTasksRule.java

    r1973 r1976  
    188188         
    189189        RuleApplicationData appData = new RuleApplicationData(sessions); 
     190        //int mergecount = 0; 
    190191         
    191192        do { 
    192193            appData.setTaskModel(taskFactory.createTaskModel(sessions)); 
     194             
     195            /*mergecount++; 
     196            if ((mergecount > 140) && ((mergecount % 20) == 0)) { 
     197                System.out.println("performing validation " + mergecount); 
     198                new TaskTreeValidator().validate(appData.getTaskModel().getUserSessions(), true); 
     199            }*/ 
     200             
     201             
    193202            appData.setMostSimilarTasks(null); 
    194203             
     
    319328                        super.visit(optionalInstance); 
    320329                         
    321                         if (optionalInstance.getChild() == null) { 
    322                             return; 
    323                         } 
    324                          
    325                         // there may have been a model update at the child. If so, set the 
    326                         // new marked task 
    327330                        IOptional optional = optionalInstance.getOptional(); 
    328                         ITask newChildTask = optionalInstance.getChild().getTask(); 
    329                          
    330                         if (newChildTask != optional.getMarkedTask()) { 
    331                             taskBuilder.setMarkedTask(optional, newChildTask); 
    332                         } 
    333                          
     331 
     332                        if (optionalInstance.getChild() != null) { 
     333                            // there may have been a model update at the child. If so, set the 
     334                            // new marked task 
     335                            ITask newChildTask = optionalInstance.getChild().getTask(); 
     336 
     337                            if (newChildTask != optional.getMarkedTask()) { 
     338                                taskBuilder.setMarkedTask(optional, newChildTask); 
     339                            } 
     340                        } 
     341 
    334342                        // check, if there is a harmonized optional 
    335343                        IOptional harmonizedOptional = 
    336344                            harmonizedOptionals.get(optional.getMarkedTask()); 
    337                          
     345 
    338346                        if ((harmonizedOptional != null) && (optional != harmonizedOptional)) { 
    339347                            // there is a harmonized optional --> set it as new task 
     
    869877        for (TaskPath path : leftHandSideTraversal.getTraversalPaths()) { 
    870878            for (FlattenInstruction instruction : result) { 
    871                 if (instruction.matches(path)) { 
     879                if ((instruction.getInstruction() != FlattenInstruction.Instruction.INTEGRATE_OPTIONAL) && 
     880                    (instruction.matches(path))) 
     881                { 
    872882                    continue OUTER; 
    873883                } 
     
    880890        for (TaskPath path : rightHandSideTraversal.getTraversalPaths()) { 
    881891            for (FlattenInstruction instruction : result) { 
    882                 if (instruction.matches(path)) { 
     892                if ((instruction.getInstruction() != FlattenInstruction.Instruction.INTEGRATE_OPTIONAL) && 
     893                    (instruction.matches(path))) 
     894                { 
    883895                    continue OUTER; 
    884896                } 
     
    982994                                 List<TaskPath>           previousPaths) 
    983995    { 
    984         boolean instructionApplied = false; 
    985996         
    986997        TaskComparator comp = identTaskHandlStrat.getTaskComparator(); 
    987998         
    988         //System.out.println("applying instructions on " + taskPath); 
     999        // System.out.println("applying integrate optional instructions on " + taskPath); 
     1000         
     1001        for (FlattenInstruction instruction : flattenInstructions) { 
     1002            if ((instruction.getInstruction() == FlattenInstruction.Instruction.INTEGRATE_OPTIONAL) && 
     1003                (instruction.matches(taskPath))) 
     1004            { 
     1005                // System.out.print("found instruction "); 
     1006                // instruction.dump(System.out); 
     1007                TaskPath previousPath = previousPaths.size() > 0 ? 
     1008                    previousPaths.get(previousPaths.size() - 1) : null; 
     1009                 
     1010                if (pathsMatch(instruction.getPrecedingPath(), previousPath)) { 
     1011                    IOptional optional = instruction.getOptional(); 
     1012                    IOptionalInstance optionalInstance = 
     1013                            taskFactory.createNewTaskInstance(optional); 
     1014                    taskBuilder.addTaskInstance(session, optionalInstance); 
     1015                } 
     1016                 
     1017                break; 
     1018            } 
     1019        } 
     1020         
     1021        boolean instanceHandled = false; 
     1022        // System.out.println("applying other instructions on " + taskPath); 
    9891023         
    9901024        for (FlattenInstruction instruction : flattenInstructions) { 
    9911025            if (instruction.matches(taskPath)) { 
    992                 //System.out.print("found instruction "); 
    993                 //instruction.dump(System.out); 
     1026                // System.out.print("found instruction "); 
     1027                // instruction.dump(System.out); 
    9941028                 
    9951029                switch (instruction.getInstruction()) { 
     
    9981032                            taskBuilder.addTaskInstance(session, instance); 
    9991033                        } 
    1000                         instructionApplied = true; 
     1034                        instanceHandled = true; 
    10011035                        break; 
    10021036                    } 
    10031037                    case MAKE_OPTIONAL: { 
    1004                         instructionApplied = true; 
    1005  
     1038                        instanceHandled = true; 
     1039                         
    10061040                        if (instance == null) { 
    10071041                            break; 
     
    10301064                    } 
    10311065                    case MAKE_SELECTION: { 
    1032                         instructionApplied = true; 
     1066                        instanceHandled = true; 
    10331067 
    10341068                        if (instance == null) { 
     
    10721106                    } 
    10731107                    case INTEGRATE_OPTIONAL: { 
    1074                         TaskPath previousPath = previousPaths.size() > 0 ? 
    1075                             previousPaths.get(previousPaths.size() - 1) : null; 
    1076                          
    1077                         if (pathsMatch(instruction.getPrecedingPath(), previousPath)) { 
    1078                             IOptional optional = instruction.getOptional(); 
    1079                             IOptionalInstance optionalInstance = 
    1080                                     taskFactory.createNewTaskInstance(optional); 
    1081                             taskBuilder.addTaskInstance(session, optionalInstance); 
    1082                         } 
    1083                          
    1084                         if (instance != null) { 
    1085                             taskBuilder.addTaskInstance(session, instance); 
    1086                         } 
    1087                          
    1088                         instructionApplied = true; 
     1108                        // have been applied beforehand 
    10891109                        break; 
    10901110                    } 
     
    10951115            } 
    10961116             
    1097             if (instructionApplied) { 
     1117            if (instanceHandled) { 
    10981118                break; 
    10991119            } 
    11001120        } 
    11011121         
    1102         if (!instructionApplied) { 
     1122        if (!instanceHandled) { 
    11031123            ITask task = taskPath.getLast(); 
    11041124            if (task instanceof IIteration) { 
Note: See TracChangeset for help on using the changeset viewer.