Ignore:
Timestamp:
02/21/13 18:39:13 (11 years ago)
Author:
pharms
Message:
  • changed rules to be testable on their own
  • added first version for a task detection rule
  • refactored rules to have a simpler interface
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java

    r1045 r1107  
    6161 * @author Patrick Harms 
    6262 */ 
    63 public class DefaultIterationDetectionRule implements TemporalRelationshipRule { 
    64      
     63class DefaultIterationDetectionRule implements TemporalRelationshipRule { 
     64 
     65    /** 
     66     * <p> 
     67     * the maximum length for iterated sequences 
     68     * </p> 
     69     */ 
    6570    private static final int MAX_LENGTH_OF_ITERATED_SEQUENCE = 50; 
    6671     
    6772    /** 
    6873     * <p> 
     74     * the task tree node factory to be used for creating substructures for the temporal 
     75     * relationships identified during rule 
     76     * </p> 
     77     */ 
     78    private ITaskTreeNodeFactory taskTreeNodeFactory; 
     79    /** 
     80     * <p> 
     81     * the task tree builder to be used for creating substructures for the temporal relationships 
     82     * identified during rule application 
     83     * </p> 
     84     */ 
     85    private ITaskTreeBuilder taskTreeBuilder; 
     86 
     87    /** 
     88     * <p> 
    6989     * the node equality manager needed for comparing task tree nodes with each other 
    7090     * </p> 
    … …  
    87107     */ 
    88108    DefaultIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager, 
    89                                   NodeEquality            minimalNodeEquality) 
     109                                  NodeEquality            minimalNodeEquality, 
     110                                  ITaskTreeNodeFactory    taskTreeNodeFactory, 
     111                                  ITaskTreeBuilder        taskTreeBuilder) 
    90112    { 
    91         super(); 
    92113        this.nodeEqualityRuleManager = nodeEqualityRuleManager; 
    93114        this.minimalNodeEquality = minimalNodeEquality; 
     115        this.taskTreeNodeFactory = taskTreeNodeFactory; 
     116        this.taskTreeBuilder = taskTreeBuilder; 
    94117    } 
    95118 
    … …  
    97120     * (non-Javadoc) 
    98121     *  
    99      * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) 
     122     * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, 
     123     * boolean) 
    100124     */ 
    101125    @Override 
    102     public RuleApplicationResult apply(ITaskTreeNode        parent, 
    103                                        ITaskTreeBuilder     treeBuilder, 
    104                                        ITaskTreeNodeFactory nodeFactory, 
    105                                        boolean              finalize) 
    106     { 
     126    public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { 
    107127        if (!(parent instanceof ISequence)) { 
    108128            return null; 
    … …  
    122142         
    123143         
    124         SubSequences subSequences = getEqualSubsequences(parent, treeBuilder, nodeFactory); 
     144        SubSequences subSequences = getEqualSubsequences(parent); 
    125145 
    126146        if (subSequences != null) { 
    127147            RuleApplicationResult result = new RuleApplicationResult(); 
    128148 
    129             mergeEqualNodes(subSequences.equalVariants, treeBuilder, nodeFactory); 
    130             IIteration newIteration = createIterationBasedOnIdentifiedVariants 
    131                 (subSequences, treeBuilder, nodeFactory, result); 
     149            mergeEqualNodes(subSequences.equalVariants); 
     150            IIteration newIteration = 
     151                createIterationBasedOnIdentifiedVariants(subSequences, result); 
    132152 
    133153            determineNewlyCreatedParentTasks(parent, newIteration, result); 
    … …  
    135155            // remove iterated children 
    136156            for (int j = subSequences.start; j < subSequences.end; j++) { 
    137                 treeBuilder.removeChild((ISequence) parent, subSequences.start); 
     157                taskTreeBuilder.removeChild((ISequence) parent, subSequences.start); 
    138158            } 
    139159 
    140160            // add the new iteration instead 
    141             treeBuilder.addChild((ISequence) parent, subSequences.start, newIteration); 
     161            taskTreeBuilder.addChild((ISequence) parent, subSequences.start, newIteration); 
    142162 
    143163            result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); 
    … …  
    161181     *  
    162182     * @param parent      the parent node in which iterations of children shall be found 
    163      * @param treeBuilder the tree builder that can be used for connecting task tree nodes 
    164      * @param nodeFactory the node factory that can be used for instantiating task tree nodes 
    165183     *  
    166184     * @return the iterated subsequences identified in a specific part (contains the equal 
    … …  
    168186     *         subpart in which the sequences were found)  
    169187     */ 
    170     private SubSequences getEqualSubsequences(ITaskTreeNode        parent, 
    171                                               ITaskTreeBuilder     treeBuilder, 
    172                                               ITaskTreeNodeFactory nodeFactory) 
    173     { 
     188    private SubSequences getEqualSubsequences(ITaskTreeNode parent) { 
    174189        SubSequences subSequences = null; 
    175190 
    … …  
    184199 
    185200                boolean foundFurtherVariants = findFurtherVariants 
    186                     (subSequences, parent, start, end, treeBuilder, nodeFactory, 
    187                      useEqualSublistLengths); 
     201                    (subSequences, parent, start, end, useEqualSublistLengths); 
    188202 
    189203                if (foundFurtherVariants) { 
    … …  
    247261     * @param end                    the end index (exclusive) of the current subpart of children 
    248262     *                               in which iterations are searched for 
    249      * @param treeBuilder            the tree builder that can be used for connecting task tree 
    250      *                               nodes 
    251      * @param nodeFactory            the node factory that can be used for instantiating task tree 
    252      *                               nodes 
    253263     * @param useEqualSublistLengths true if the sublists to be searched for all need to have the 
    254264     *                               same length 
    … …  
    260270                                        int                  start, 
    261271                                        int                  end, 
    262                                         ITaskTreeBuilder     treeBuilder, 
    263                                         ITaskTreeNodeFactory nodeFactory, 
    264272                                        boolean              useEqualSublistLengths) 
    265273    { 
    … …  
    279287            } 
    280288             
    281             ISequence furtherVariant = nodeFactory.createNewSequence(); 
     289            ISequence furtherVariant = taskTreeNodeFactory.createNewSequence(); 
    282290             
    283291            for (int j = start; j < start + childCount; j++) { 
    284                 treeBuilder.addChild(furtherVariant, parent.getChildren().get(j)); 
     292                taskTreeBuilder.addChild(furtherVariant, parent.getChildren().get(j)); 
    285293            } 
    286294             
    … …  
    305313                 
    306314                foundFurtherVariants = findFurtherVariants 
    307                     (subSequences, parent, start + childCount, end, treeBuilder, nodeFactory, 
    308                      useEqualSublistLengths); 
     315                    (subSequences, parent, start + childCount, end, useEqualSublistLengths); 
    309316 
    310317                if (foundFurtherVariants) { 
    … …  
    331338     * 
    332339     * @param nodes       the list of nodes to be merged 
    333      * @param treeBuilder the tree builder that can be used for connecting task tree nodes 
    334      * @param nodeFactory the node factory that can be used for instantiating task tree nodes 
    335      */ 
    336     private void mergeEqualNodes(List<ITaskTreeNode>   nodes, 
    337                                  ITaskTreeBuilder      treeBuilder, 
    338                                  ITaskTreeNodeFactory  nodeFactory) 
    339     { 
     340     */ 
     341    private void mergeEqualNodes(List<ITaskTreeNode> nodes) { 
    340342        int index1 = 0; 
    341343        int index2 = 0; 
    … …  
    349351            while (index2 < nodes.size()) { 
    350352                variant2 = nodes.get(index2); 
    351                 ITaskTreeNode mergedChild = 
    352                     mergeEqualTasks(variant1, variant2, treeBuilder, nodeFactory); 
     353                ITaskTreeNode mergedChild = mergeEqualTasks(variant1, variant2); 
    353354                 
    354355                if (mergedChild != null) { 
    … …  
    382383     * @param node1       the first task to be merged 
    383384     * @param node2       the second task to be merged 
    384      * @param treeBuilder the tree builder that can be used for connecting task tree nodes 
    385      * @param nodeFactory the node factory that can be used for instantiating task tree nodes 
    386385     *  
    387386     * @return the result of the merge 
    388387     */ 
    389     private ITaskTreeNode mergeEqualTasks(ITaskTreeNode         node1, 
    390                                           ITaskTreeNode         node2, 
    391                                           ITaskTreeBuilder      treeBuilder, 
    392                                           ITaskTreeNodeFactory  nodeFactory) 
    393     { 
     388    private ITaskTreeNode mergeEqualTasks(ITaskTreeNode node1, ITaskTreeNode node2) { 
    394389        ITaskTreeNode mergeResult = null; 
    395390         
    396391        if ((node1 instanceof ISequence) && (node2 instanceof ISequence)) { 
    397             mergeResult = mergeEqualSequences 
    398                 ((ISequence) node1, (ISequence) node2, treeBuilder, nodeFactory); 
     392            mergeResult = mergeEqualSequences((ISequence) node1, (ISequence) node2); 
    399393        } 
    400394        else if ((node1 instanceof ISelection) && (node2 instanceof ISelection)) { 
    401             mergeResult = mergeEqualSelections 
    402                 ((ISelection) node1, (ISelection) node2, treeBuilder, nodeFactory); 
     395            mergeResult = mergeEqualSelections((ISelection) node1, (ISelection) node2); 
    403396        } 
    404397        else if ((node1 instanceof IIteration) && (node2 instanceof IIteration)) { 
    405             mergeResult = mergeEqualIterations 
    406                 ((IIteration) node1, (IIteration) node2, treeBuilder, nodeFactory); 
     398            mergeResult = mergeEqualIterations((IIteration) node1, (IIteration) node2); 
    407399        } 
    408400        else if (node1 instanceof ISelection) { 
    409             treeBuilder.addChild((ISelection) node1, node2); 
     401            taskTreeBuilder.addChild((ISelection) node1, node2); 
    410402            mergeResult = node1; 
    411403        } 
    412404        else if (node2 instanceof ISelection) { 
    413             treeBuilder.addChild((ISelection) node2, node1); 
     405            taskTreeBuilder.addChild((ISelection) node2, node1); 
    414406            mergeResult = node2; 
    415407        } 
    416408        else if (node1 instanceof IIteration) { 
    417             mergeResult = mergeEqualTasks 
    418                 (((IIteration) node1).getChildren().get(0), node2, treeBuilder, nodeFactory); 
     409            mergeResult = mergeEqualTasks(((IIteration) node1).getChildren().get(0), node2); 
    419410             
    420411            if (mergeResult != null) { 
    421                 IIteration iteration = nodeFactory.createNewIteration(); 
    422                 treeBuilder.setChild(iteration, mergeResult); 
     412                IIteration iteration = taskTreeNodeFactory.createNewIteration(); 
     413                taskTreeBuilder.setChild(iteration, mergeResult); 
    423414                mergeResult = iteration; 
    424415            } 
    425416        } 
    426417        else if (node2 instanceof IIteration) { 
    427             mergeResult = mergeEqualTasks 
    428                 (((IIteration) node2).getChildren().get(0), node1, treeBuilder, nodeFactory); 
     418            mergeResult = mergeEqualTasks(((IIteration) node2).getChildren().get(0), node1); 
    429419             
    430420            if (mergeResult != null) { 
    431                 IIteration iteration = nodeFactory.createNewIteration(); 
    432                 treeBuilder.setChild(iteration, mergeResult); 
     421                IIteration iteration = taskTreeNodeFactory.createNewIteration(); 
     422                taskTreeBuilder.setChild(iteration, mergeResult); 
    433423                mergeResult = iteration; 
    434424            } 
    … …  
    443433 
    444434        if (mergeResult == null) { 
    445             mergeResult = nodeFactory.createNewSelection(); 
    446             treeBuilder.addChild((ISelection) mergeResult, node1); 
    447             treeBuilder.addChild((ISelection) mergeResult, node2); 
     435            mergeResult = taskTreeNodeFactory.createNewSelection(); 
     436            taskTreeBuilder.addChild((ISelection) mergeResult, node1); 
     437            taskTreeBuilder.addChild((ISelection) mergeResult, node2); 
    448438        } 
    449439         
    … …  
    463453     * @param sequence1   the first sequence to be merged 
    464454     * @param sequence2   the second sequence to be merged 
    465      * @param treeBuilder the tree builder that can be used for connecting task tree nodes 
    466      * @param nodeFactory the node factory that can be used for instantiating task tree nodes 
    467455     *  
    468456     * @return the result of the merge or null if merging was not possible 
    469457     */ 
    470     private ISequence mergeEqualSequences(ISequence             sequence1, 
    471                                           ISequence             sequence2, 
    472                                           ITaskTreeBuilder      treeBuilder, 
    473                                           ITaskTreeNodeFactory  nodeFactory) 
    474     { 
     458    private ISequence mergeEqualSequences(ISequence sequence1, ISequence sequence2) { 
    475459        ISequence mergeResult = null; 
    476460         
    477461        if (sequence1.getChildren().size() == sequence2.getChildren().size()) { 
    478             mergeResult = nodeFactory.createNewSequence(); 
     462            mergeResult = taskTreeNodeFactory.createNewSequence(); 
    479463             
    480464            for (int i = 0; i < sequence1.getChildren().size(); i++) { 
    481465                ITaskTreeNode mergedNode = mergeEqualTasks 
    482                     (sequence1.getChildren().get(i), sequence2.getChildren().get(i), 
    483                      treeBuilder, nodeFactory); 
     466                    (sequence1.getChildren().get(i), sequence2.getChildren().get(i)); 
    484467                 
    485468                if (mergedNode != null) { 
    486                     treeBuilder.addChild(mergeResult, mergedNode); 
     469                    taskTreeBuilder.addChild(mergeResult, mergedNode); 
    487470                } 
    488471                else { 
    … …  
    506489     * @param selection1  the first selection to be merged 
    507490     * @param selection2  the second selection to be merged 
    508      * @param treeBuilder the tree builder that can be used for connecting task tree nodes 
    509      * @param nodeFactory the node factory that can be used for instantiating task tree nodes 
    510491     *  
    511492     * @return the result of the merge which is never null 
    512493     */ 
    513     private ITaskTreeNode mergeEqualSelections(ISelection            selection1, 
    514                                                ISelection            selection2, 
    515                                                ITaskTreeBuilder      treeBuilder, 
    516                                                ITaskTreeNodeFactory  nodeFactory) 
    517     { 
     494    private ITaskTreeNode mergeEqualSelections(ISelection selection1, ISelection selection2) { 
    518495        ISelection mergeResult = selection1; 
    519496         
    … …  
    526503            childToMerge = selection2.getChildren().get(i); 
    527504            for (int j = 0; j < selection1.getChildren().size(); j++) { 
    528                 mergedChild = mergeEqualTasks 
    529                     (selection1.getChildren().get(j), childToMerge, treeBuilder, nodeFactory); 
     505                mergedChild = mergeEqualTasks(selection1.getChildren().get(j), childToMerge); 
    530506                 
    531507                // a merge must not be a selection, except it is one of the children. Otherwise 
    … …  
    538514                    // we found a real merge. So replace the original child in selection 1 with 
    539515                    // the merged child 
    540                     treeBuilder.removeChild(selection1, selection1.getChildren().get(j)); 
    541                     treeBuilder.addChild(selection1, mergedChild); 
     516                    taskTreeBuilder.removeChild(selection1, selection1.getChildren().get(j)); 
     517                    taskTreeBuilder.addChild(selection1, mergedChild); 
    542518                    mergedChild = null; 
    543519                    childToMerge = null; 
    … …  
    547523             
    548524            if (childToMerge != null) { 
    549                 treeBuilder.addChild(selection1, childToMerge); 
     525                taskTreeBuilder.addChild(selection1, childToMerge); 
    550526            } 
    551527        } 
    … …  
    563539     * @param selection1  the first iteration to be merged 
    564540     * @param selection2  the second iteration to be merged 
    565      * @param treeBuilder the tree builder that can be used for connecting task tree nodes 
    566      * @param nodeFactory the node factory that can be used for instantiating task tree nodes 
    567541     *  
    568542     * @return the result of the merge or null if merging is not possible 
    569543     */ 
    570     private ITaskTreeNode mergeEqualIterations(IIteration            iteration1, 
    571                                                IIteration            iteration2, 
    572                                                ITaskTreeBuilder      treeBuilder, 
    573                                                ITaskTreeNodeFactory  nodeFactory) 
    574     { 
     544    private ITaskTreeNode mergeEqualIterations(IIteration iteration1, IIteration iteration2) { 
    575545        ITaskTreeNode mergedChild = mergeEqualTasks 
    576             (iteration1.getChildren().get(0), iteration2.getChildren().get(0), 
    577              treeBuilder, nodeFactory); 
     546            (iteration1.getChildren().get(0), iteration2.getChildren().get(0)); 
    578547         
    579548        IIteration mergeResult = null; 
    580549         
    581550        if (mergedChild != null) { 
    582             mergeResult = nodeFactory.createNewIteration(); 
    583             treeBuilder.setChild(mergeResult, mergedChild); 
     551            mergeResult = taskTreeNodeFactory.createNewIteration(); 
     552            taskTreeBuilder.setChild(mergeResult, mergedChild); 
    584553        } 
    585554         
    … …  
    598567     * 
    599568     * @param subsequences the identified and already merged equal subsequences 
    600      * @param treeBuilder  the tree builder that can be used for connecting task tree nodes 
    601      * @param nodeFactory  the node factory that can be used for instantiating the iteration 
    602569     *  
    603570     * @return the resulting iteration 
    604571     */ 
    605572    private IIteration createIterationBasedOnIdentifiedVariants(SubSequences          subsequences, 
    606                                                                 ITaskTreeBuilder      treeBuilder, 
    607                                                                 ITaskTreeNodeFactory  nodeFactory, 
    608573                                                                RuleApplicationResult result) 
    609574    { 
    610         IIteration newIteration = nodeFactory.createNewIteration(); 
     575        IIteration newIteration = taskTreeNodeFactory.createNewIteration(); 
    611576        result.addNewlyCreatedParentNode(newIteration); 
    612577 
    … …  
    616581                // there is only one equal variant and this has only one child. So create an 
    617582                // iteration of this child 
    618                 treeBuilder.setChild 
     583                taskTreeBuilder.setChild 
    619584                    (newIteration, subsequences.equalVariants.get(0).getChildren().get(0)); 
    620585            } 
    621586            else { 
    622587                // there was an iteration of one equal sequence 
    623                 treeBuilder.setChild(newIteration, subsequences.equalVariants.get(0)); 
     588                taskTreeBuilder.setChild(newIteration, subsequences.equalVariants.get(0)); 
    624589                result.addNewlyCreatedParentNode(subsequences.equalVariants.get(0)); 
    625590            } 
    … …  
    628593            // there are distinct variants of equal subsequences or children --> create an 
    629594            // iterated selection 
    630             ISelection selection = nodeFactory.createNewSelection(); 
     595            ISelection selection = taskTreeNodeFactory.createNewSelection(); 
    631596            result.addNewlyCreatedParentNode(selection); 
    632597 
    633598            for (ITaskTreeNode variant : subsequences.equalVariants) { 
    634599                if (variant.getChildren().size() == 1) { 
    635                     treeBuilder.addChild(selection, variant.getChildren().get(0)); 
     600                    taskTreeBuilder.addChild(selection, variant.getChildren().get(0)); 
    636601                } 
    637602                else { 
    638                     treeBuilder.addChild(selection, variant); 
     603                    taskTreeBuilder.addChild(selection, variant); 
    639604                    result.addNewlyCreatedParentNode(variant); 
    640605                } 
    641606            } 
    642607 
    643             treeBuilder.setChild(newIteration, selection); 
     608            taskTreeBuilder.setChild(newIteration, selection); 
    644609        } 
    645610         
Note: See TracChangeset for help on using the changeset viewer.