Ignore:
Timestamp:
09/05/14 19:33:12 (10 years ago)
Author:
rkrimmel
Message:

Used Eclipse code cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRule.java

    r1294 r1733  
    2424/** 
    2525 * <p> 
    26  * this task comparison rule is capable of comparing selections. If both selections do not have 
    27  * children, they are treated as lexically equal. If they have children, each child of both 
    28  * selections is compared to each child of the respective other selection. The resulting equality 
    29  * is the most concrete one of all these comparisons. I.e. if all children are at least lexically 
    30  * equal, then the selections are lexically equal. If all children are at least syntactically 
    31  * equal, then the selections are syntactically equal. If all children are at least semantically 
    32  * equal, then the selections are semantically equal. If only one of the selections has children, 
    33  * then the selections are unequal. The comparison is broken up, if only a specific equality is 
    34  * checked for and this equality is ensured. 
     26 * this task comparison rule is capable of comparing selections. If both 
     27 * selections do not have children, they are treated as lexically equal. If they 
     28 * have children, each child of both selections is compared to each child of the 
     29 * respective other selection. The resulting equality is the most concrete one 
     30 * of all these comparisons. I.e. if all children are at least lexically equal, 
     31 * then the selections are lexically equal. If all children are at least 
     32 * syntactically equal, then the selections are syntactically equal. If all 
     33 * children are at least semantically equal, then the selections are 
     34 * semantically equal. If only one of the selections has children, then the 
     35 * selections are unequal. The comparison is broken up, if only a specific 
     36 * equality is checked for and this equality is ensured. 
    3537 * </p> 
    3638 *  
    … …  
    4042public class SelectionComparisonRule implements TaskComparisonRule { 
    4143 
    42     /* (non-Javadoc) 
    43      * @see TaskComparisonRule#isApplicable(ITask, ITask) 
    44      */ 
    45     @Override 
    46     public boolean isApplicable(ITask task1, ITask task2) { 
    47         return (task1 instanceof ISelection) && (task2 instanceof ISelection); 
    48     } 
    49  
    50     /* (non-Javadoc) 
    51      * @see TaskComparisonRule#areLexicallyEqual(ITask, ITask) 
    52      */ 
    53     @Override 
    54     public boolean areLexicallyEqual(ITask task1, ITask task2) { 
    55         TaskEquality equality = getEquality(task1, task2, TaskEquality.LEXICALLY_EQUAL); 
    56         return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
    57     } 
    58  
    59     /* (non-Javadoc) 
    60      * @see TaskComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    61      */ 
    62     @Override 
    63     public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
    64         TaskEquality equality = getEquality(task1, task2, TaskEquality.SYNTACTICALLY_EQUAL); 
    65         return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
    66     } 
    67  
    68     /* (non-Javadoc) 
    69      * @see TaskComparisonRule#areSemanticallyEqual(ITask, ITask) 
    70      */ 
    71     @Override 
    72     public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
    73         TaskEquality equality = getEquality(task1, task2, TaskEquality.SEMANTICALLY_EQUAL); 
    74         return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
    75     } 
    76  
    77     /* (non-Javadoc) 
    78      * @see TaskComparisonRule#compare(ITask, ITask) 
    79      */ 
    80     @Override 
    81     public TaskEquality compare(ITask task1, ITask task2) { 
    82         return getEquality(task1, task2, null); 
    83     } 
    84  
    85     /* (non-Javadoc) 
    86      * @see TaskComparisonRule#isApplicable(ITaskInstance, ITaskInstance) 
    87      */ 
    88     @Override 
    89     public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2) { 
    90         return isApplicable(instance1.getTask(), instance2.getTask()); 
    91     } 
    92  
    93     /* (non-Javadoc) 
    94      * @see TaskComparisonRule#areLexicallyEqual(ITaskInstance, ITaskInstance) 
    95      */ 
    96     @Override 
    97     public boolean areLexicallyEqual(ITaskInstance instance1, ITaskInstance instance2) { 
    98         TaskEquality equality = getEquality(instance1, instance2, TaskEquality.LEXICALLY_EQUAL); 
    99         return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
    100     } 
    101  
    102     /* (non-Javadoc) 
    103      * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance, ITaskInstance) 
    104      */ 
    105     @Override 
    106     public boolean areSyntacticallyEqual(ITaskInstance instance1, ITaskInstance instance2) { 
    107         TaskEquality equality = getEquality(instance1, instance2, TaskEquality.SYNTACTICALLY_EQUAL); 
    108         return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
    109     } 
    110  
    111     /* (non-Javadoc) 
    112      * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance, ITaskInstance) 
    113      */ 
    114     @Override 
    115     public boolean areSemanticallyEqual(ITaskInstance instance1, ITaskInstance instance2) { 
    116         TaskEquality equality = getEquality(instance1, instance2, TaskEquality.SEMANTICALLY_EQUAL); 
    117         return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
    118     } 
    119  
    120     /* (non-Javadoc) 
    121      * @see TaskComparisonRule#compare(ITaskInstance, ITaskInstance) 
    122      */ 
    123     @Override 
    124     public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2) { 
    125         return getEquality(instance1, instance2, null); 
    126     } 
    127  
    128     /** 
    129      * <p> 
    130      * compares two selections with each other checking for the provided required level of 
    131      * equality. If this level is ensured, the method immediately returns. The more concrete 
    132      * the required equality level, the more checks this method performs. 
    133      * </p> 
    134      *  
    135      * @param task1                 the first task to be compared 
    136      * @param task2                 the second task to be compared 
    137      * @param requiredEqualityLevel the equality level to be checked for 
    138      *  
    139      * @return the determined equality. 
    140      */ 
    141     private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) { 
    142         List<ITask> children1 = ((ISelection) task1).getChildren(); 
    143         List<ITask> children2 = ((ISelection) task2).getChildren(); 
    144  
    145         // if both selections do not have children, they are lexically equal. If only one of them 
    146         // has children, they are unequal. 
    147         if ((children1.size() == 0) && (children2.size() == 0)) { 
    148             return TaskEquality.LEXICALLY_EQUAL; 
    149         } 
    150         else if ((children1.size() == 0) || (children2.size() == 0)) { 
    151             return TaskEquality.UNEQUAL; 
    152         } 
    153  
    154         if (requiredEqualityLevel == null) { 
    155             // calculate the common equality level for all children of both selections. 
    156             // do it in both directions to ensure commutative comparison 
    157             return getMostConcreteEqualityLevel(children1, children2); 
    158         } 
    159         else { 
    160             // we are searching for a specific equality 
    161             if (checkEqualityLevel(children1, children2, requiredEqualityLevel)) { 
    162                 return requiredEqualityLevel; 
    163             } 
    164             else { 
    165                 return TaskEquality.UNEQUAL; 
    166             } 
    167         } 
    168     } 
    169  
    170     /** 
    171      * <p> 
    172      * determines the most concrete equality level for all tasks in the first list compared to all 
    173      * tasks in the second list. It is sufficient, if there is one task in one list for which there 
    174      * exist an equal task in the other list. 
    175      * </p> 
    176      * 
    177      * @param children1 the first list to be compared 
    178      * @param children2 the second list to be compared 
    179      *  
    180      * @return the most concrete task equality identified for all tasks in the first list with 
    181      *         respect to the second list 
    182      */ 
    183     private TaskEquality getMostConcreteEqualityLevel(List<ITask> children1, List<ITask> children2) 
    184     { 
    185         TaskEquality childEquality; 
    186         TaskEquality currentEquality; 
    187         for (ITask child1 : children1) { 
    188             childEquality = null; 
    189             for (ITask child2 : children2) { 
    190                 currentEquality = callRuleManager(child1, child2, null); 
    191                 if ((currentEquality != null) && (currentEquality != TaskEquality.UNEQUAL)) { 
    192                     if (childEquality == null) { 
    193                         childEquality = currentEquality; 
    194                     } 
    195                     else { 
    196                         childEquality = childEquality.getCommonDenominator(currentEquality); 
    197                     } 
    198                      
    199                     if (childEquality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)) { 
    200                         // as we calculate the most concrete equality, we can break up here 
    201                         return TaskEquality.LEXICALLY_EQUAL; 
    202                     } 
    203                 } 
    204             } 
    205         } 
    206  
    207         // as the comparison should be commutative, we do not need to check, if in list 2 there is 
    208         // a child equal to one in list 1 
    209         return TaskEquality.UNEQUAL; 
    210     } 
    211  
    212     /** 
    213      * <p> 
    214      * ensures for the two given lists, that for at least one task in the first list there is a task 
    215      * in the second list being on the given level equal to the task in the first list. 
    216      * </p>  
    217      *  
    218      * @param children1             the first list to be compared 
    219      * @param children2             the second list to be compared 
    220      * @param requiredEqualityLevel the equality level to be checked for 
    221      *  
    222      * @return true if there is a task in the first list that has an equal task in the second list 
    223      *         when considering the given equality level, false else. 
    224      */ 
    225     private boolean checkEqualityLevel(List<ITask>  children1, 
    226                                        List<ITask>  children2, 
    227                                        TaskEquality requiredEqualityLevel) 
    228     { 
    229         TaskEquality currentEquality; 
    230         for (ITask child1 : children1) { 
    231             for (ITask child2 : children2) { 
    232                 currentEquality = callRuleManager(child1, child2, requiredEqualityLevel); 
    233                 if ((currentEquality != null) && (currentEquality.isAtLeast(requiredEqualityLevel))) 
    234                 { 
    235                     // we found at least one equal child with sufficient equality in the 
    236                     // second list. So be can break up for this child. 
    237                     return true; 
    238                 } 
    239             } 
    240         } 
    241  
    242         return false; 
    243     } 
    244  
    245     /** 
    246      * <p> 
    247      * used to to call the task equality rule manager for the comparison of the two provided 
    248      * children. If no required equality level is provided, than the most concrete equality is 
    249      * returned. Otherwise, the required equality is returned as long as the children are equal 
    250      * on that level. 
    251      * </p>  
    252      *  
    253      * @param child1                the first task to be compared 
    254      * @param child2                the second task to be compared 
    255      * @param requiredEqualityLevel the equality level to be checked for 
    256      *  
    257      * @return the determined equality 
    258      */ 
    259     private TaskEquality callRuleManager(ITask        child1, 
    260                                          ITask        child2, 
    261                                          TaskEquality requiredEqualityLevel) 
    262     { 
    263         if (requiredEqualityLevel == null) { 
    264             return TaskEqualityRuleManager.getInstance().compare(child1, child2); 
    265         } 
    266         else if (TaskEqualityRuleManager.getInstance().areAtLeastEqual 
    267                      (child1, child2, requiredEqualityLevel)) 
    268         { 
    269             return requiredEqualityLevel; 
    270         } 
    271         else { 
    272             return TaskEquality.UNEQUAL; 
    273         } 
    274     } 
    275  
    276     /** 
    277      * <p> 
    278      * compares two selection instances with each other checking for the provided required level of 
    279      * equality. If this level is ensured, the method immediately returns. The more concrete 
    280      * the required equality level, the more checks this method performs. 
    281      * </p> 
    282      *  
    283      * @param taskInstance1         the first task instance to be compared 
    284      * @param taskInstance2         the second task instance to be compared 
    285      * @param requiredEqualityLevel the equality level to be checked for 
    286      *  
    287      * @return the determined equality. 
    288      */ 
    289     private TaskEquality getEquality(ITaskInstance taskInstance1, 
    290                                      ITaskInstance taskInstance2, 
    291                                      TaskEquality  requiredEqualityLevel) 
    292     { 
    293         ITaskInstance child1 = ((ISelectionInstance) taskInstance1).getChild(); 
    294         ITaskInstance child2 = ((ISelectionInstance) taskInstance2).getChild(); 
    295  
    296         // if both selections do not have children, they are lexically equal. If only one of them 
    297         // has children, they are unequal. 
    298         if ((child1 == null) && (child2 == null)) { 
    299             return TaskEquality.LEXICALLY_EQUAL; 
    300         } 
    301         else if ((child1 == null) || (child2 == null)) { 
    302             return TaskEquality.UNEQUAL; 
    303         } 
    304  
    305         TaskEquality equality = callRuleManager(child1, child2, requiredEqualityLevel); 
    306          
    307         if (equality == TaskEquality.IDENTICAL) { 
    308             // two different selection instances can be at most lexically equal even if their 
    309             // children are identical 
    310             return TaskEquality.LEXICALLY_EQUAL; 
    311         } 
    312         else { 
    313             return equality; 
    314         } 
    315     } 
    316  
    317     /** 
    318      * <p> 
    319      * used to to call the task equality rule manager for the comparison of the two provided 
    320      * children. If no required equality level is provided, than the most concrete equality is 
    321      * returned. Otherwise, the required equality is returned as long as the children are equal 
    322      * on that level. 
    323      * </p>  
    324      *  
    325      * @param taskInstance1         the first task instance to be compared 
    326      * @param taskInstance2         the second task instance to be compared 
    327      * @param requiredEqualityLevel the equality level to be checked for 
    328      *  
    329      * @return the determined equality 
    330      */ 
    331     private TaskEquality callRuleManager(ITaskInstance taskInstance1, 
    332                                          ITaskInstance taskInstance2, 
    333                                          TaskEquality  requiredEqualityLevel) 
    334     { 
    335         if (requiredEqualityLevel == null) { 
    336             return TaskEqualityRuleManager.getInstance().compare(taskInstance1, taskInstance2); 
    337         } 
    338         else if (TaskEqualityRuleManager.getInstance().areAtLeastEqual 
    339                      (taskInstance1, taskInstance2, requiredEqualityLevel)) 
    340         { 
    341             return requiredEqualityLevel; 
    342         } 
    343         else { 
    344             return TaskEquality.UNEQUAL; 
    345         } 
    346     } 
     44        /* 
     45         * (non-Javadoc) 
     46         *  
     47         * @see TaskComparisonRule#areLexicallyEqual(ITask, ITask) 
     48         */ 
     49        @Override 
     50        public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     51                final TaskEquality equality = getEquality(task1, task2, 
     52                                TaskEquality.LEXICALLY_EQUAL); 
     53                return (equality != null) 
     54                                && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
     55        } 
     56 
     57        /* 
     58         * (non-Javadoc) 
     59         *  
     60         * @see TaskComparisonRule#areLexicallyEqual(ITaskInstance, ITaskInstance) 
     61         */ 
     62        @Override 
     63        public boolean areLexicallyEqual(ITaskInstance instance1, 
     64                        ITaskInstance instance2) { 
     65                final TaskEquality equality = getEquality(instance1, instance2, 
     66                                TaskEquality.LEXICALLY_EQUAL); 
     67                return (equality != null) 
     68                                && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
     69        } 
     70 
     71        /* 
     72         * (non-Javadoc) 
     73         *  
     74         * @see TaskComparisonRule#areSemanticallyEqual(ITask, ITask) 
     75         */ 
     76        @Override 
     77        public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     78                final TaskEquality equality = getEquality(task1, task2, 
     79                                TaskEquality.SEMANTICALLY_EQUAL); 
     80                return (equality != null) 
     81                                && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
     82        } 
     83 
     84        /* 
     85         * (non-Javadoc) 
     86         *  
     87         * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance, 
     88         * ITaskInstance) 
     89         */ 
     90        @Override 
     91        public boolean areSemanticallyEqual(ITaskInstance instance1, 
     92                        ITaskInstance instance2) { 
     93                final TaskEquality equality = getEquality(instance1, instance2, 
     94                                TaskEquality.SEMANTICALLY_EQUAL); 
     95                return (equality != null) 
     96                                && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
     97        } 
     98 
     99        /* 
     100         * (non-Javadoc) 
     101         *  
     102         * @see TaskComparisonRule#areSyntacticallyEqual(ITask, ITask) 
     103         */ 
     104        @Override 
     105        public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     106                final TaskEquality equality = getEquality(task1, task2, 
     107                                TaskEquality.SYNTACTICALLY_EQUAL); 
     108                return (equality != null) 
     109                                && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
     110        } 
     111 
     112        /* 
     113         * (non-Javadoc) 
     114         *  
     115         * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance, 
     116         * ITaskInstance) 
     117         */ 
     118        @Override 
     119        public boolean areSyntacticallyEqual(ITaskInstance instance1, 
     120                        ITaskInstance instance2) { 
     121                final TaskEquality equality = getEquality(instance1, instance2, 
     122                                TaskEquality.SYNTACTICALLY_EQUAL); 
     123                return (equality != null) 
     124                                && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
     125        } 
     126 
     127        /** 
     128         * <p> 
     129         * used to to call the task equality rule manager for the comparison of the 
     130         * two provided children. If no required equality level is provided, than 
     131         * the most concrete equality is returned. Otherwise, the required equality 
     132         * is returned as long as the children are equal on that level. 
     133         * </p> 
     134         *  
     135         * @param child1 
     136         *            the first task to be compared 
     137         * @param child2 
     138         *            the second task to be compared 
     139         * @param requiredEqualityLevel 
     140         *            the equality level to be checked for 
     141         *  
     142         * @return the determined equality 
     143         */ 
     144        private TaskEquality callRuleManager(ITask child1, ITask child2, 
     145                        TaskEquality requiredEqualityLevel) { 
     146                if (requiredEqualityLevel == null) { 
     147                        return TaskEqualityRuleManager.getInstance() 
     148                                        .compare(child1, child2); 
     149                } else if (TaskEqualityRuleManager.getInstance().areAtLeastEqual( 
     150                                child1, child2, requiredEqualityLevel)) { 
     151                        return requiredEqualityLevel; 
     152                } else { 
     153                        return TaskEquality.UNEQUAL; 
     154                } 
     155        } 
     156 
     157        /** 
     158         * <p> 
     159         * used to to call the task equality rule manager for the comparison of the 
     160         * two provided children. If no required equality level is provided, than 
     161         * the most concrete equality is returned. Otherwise, the required equality 
     162         * is returned as long as the children are equal on that level. 
     163         * </p> 
     164         *  
     165         * @param taskInstance1 
     166         *            the first task instance to be compared 
     167         * @param taskInstance2 
     168         *            the second task instance to be compared 
     169         * @param requiredEqualityLevel 
     170         *            the equality level to be checked for 
     171         *  
     172         * @return the determined equality 
     173         */ 
     174        private TaskEquality callRuleManager(ITaskInstance taskInstance1, 
     175                        ITaskInstance taskInstance2, TaskEquality requiredEqualityLevel) { 
     176                if (requiredEqualityLevel == null) { 
     177                        return TaskEqualityRuleManager.getInstance().compare(taskInstance1, 
     178                                        taskInstance2); 
     179                } else if (TaskEqualityRuleManager.getInstance().areAtLeastEqual( 
     180                                taskInstance1, taskInstance2, requiredEqualityLevel)) { 
     181                        return requiredEqualityLevel; 
     182                } else { 
     183                        return TaskEquality.UNEQUAL; 
     184                } 
     185        } 
     186 
     187        /** 
     188         * <p> 
     189         * ensures for the two given lists, that for at least one task in the first 
     190         * list there is a task in the second list being on the given level equal to 
     191         * the task in the first list. 
     192         * </p> 
     193         *  
     194         * @param children1 
     195         *            the first list to be compared 
     196         * @param children2 
     197         *            the second list to be compared 
     198         * @param requiredEqualityLevel 
     199         *            the equality level to be checked for 
     200         *  
     201         * @return true if there is a task in the first list that has an equal task 
     202         *         in the second list when considering the given equality level, 
     203         *         false else. 
     204         */ 
     205        private boolean checkEqualityLevel(List<ITask> children1, 
     206                        List<ITask> children2, TaskEquality requiredEqualityLevel) { 
     207                TaskEquality currentEquality; 
     208                for (final ITask child1 : children1) { 
     209                        for (final ITask child2 : children2) { 
     210                                currentEquality = callRuleManager(child1, child2, 
     211                                                requiredEqualityLevel); 
     212                                if ((currentEquality != null) 
     213                                                && (currentEquality.isAtLeast(requiredEqualityLevel))) { 
     214                                        // we found at least one equal child with sufficient 
     215                                        // equality in the 
     216                                        // second list. So be can break up for this child. 
     217                                        return true; 
     218                                } 
     219                        } 
     220                } 
     221 
     222                return false; 
     223        } 
     224 
     225        /* 
     226         * (non-Javadoc) 
     227         *  
     228         * @see TaskComparisonRule#compare(ITask, ITask) 
     229         */ 
     230        @Override 
     231        public TaskEquality compare(ITask task1, ITask task2) { 
     232                return getEquality(task1, task2, null); 
     233        } 
     234 
     235        /* 
     236         * (non-Javadoc) 
     237         *  
     238         * @see TaskComparisonRule#compare(ITaskInstance, ITaskInstance) 
     239         */ 
     240        @Override 
     241        public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2) { 
     242                return getEquality(instance1, instance2, null); 
     243        } 
     244 
     245        /** 
     246         * <p> 
     247         * compares two selections with each other checking for the provided 
     248         * required level of equality. If this level is ensured, the method 
     249         * immediately returns. The more concrete the required equality level, the 
     250         * more checks this method performs. 
     251         * </p> 
     252         *  
     253         * @param task1 
     254         *            the first task to be compared 
     255         * @param task2 
     256         *            the second task to be compared 
     257         * @param requiredEqualityLevel 
     258         *            the equality level to be checked for 
     259         *  
     260         * @return the determined equality. 
     261         */ 
     262        private TaskEquality getEquality(ITask task1, ITask task2, 
     263                        TaskEquality requiredEqualityLevel) { 
     264                final List<ITask> children1 = ((ISelection) task1).getChildren(); 
     265                final List<ITask> children2 = ((ISelection) task2).getChildren(); 
     266 
     267                // if both selections do not have children, they are lexically equal. If 
     268                // only one of them 
     269                // has children, they are unequal. 
     270                if ((children1.size() == 0) && (children2.size() == 0)) { 
     271                        return TaskEquality.LEXICALLY_EQUAL; 
     272                } else if ((children1.size() == 0) || (children2.size() == 0)) { 
     273                        return TaskEquality.UNEQUAL; 
     274                } 
     275 
     276                if (requiredEqualityLevel == null) { 
     277                        // calculate the common equality level for all children of both 
     278                        // selections. 
     279                        // do it in both directions to ensure commutative comparison 
     280                        return getMostConcreteEqualityLevel(children1, children2); 
     281                } else { 
     282                        // we are searching for a specific equality 
     283                        if (checkEqualityLevel(children1, children2, requiredEqualityLevel)) { 
     284                                return requiredEqualityLevel; 
     285                        } else { 
     286                                return TaskEquality.UNEQUAL; 
     287                        } 
     288                } 
     289        } 
     290 
     291        /** 
     292         * <p> 
     293         * compares two selection instances with each other checking for the 
     294         * provided required level of equality. If this level is ensured, the method 
     295         * immediately returns. The more concrete the required equality level, the 
     296         * more checks this method performs. 
     297         * </p> 
     298         *  
     299         * @param taskInstance1 
     300         *            the first task instance to be compared 
     301         * @param taskInstance2 
     302         *            the second task instance to be compared 
     303         * @param requiredEqualityLevel 
     304         *            the equality level to be checked for 
     305         *  
     306         * @return the determined equality. 
     307         */ 
     308        private TaskEquality getEquality(ITaskInstance taskInstance1, 
     309                        ITaskInstance taskInstance2, TaskEquality requiredEqualityLevel) { 
     310                final ITaskInstance child1 = ((ISelectionInstance) taskInstance1) 
     311                                .getChild(); 
     312                final ITaskInstance child2 = ((ISelectionInstance) taskInstance2) 
     313                                .getChild(); 
     314 
     315                // if both selections do not have children, they are lexically equal. If 
     316                // only one of them 
     317                // has children, they are unequal. 
     318                if ((child1 == null) && (child2 == null)) { 
     319                        return TaskEquality.LEXICALLY_EQUAL; 
     320                } else if ((child1 == null) || (child2 == null)) { 
     321                        return TaskEquality.UNEQUAL; 
     322                } 
     323 
     324                final TaskEquality equality = callRuleManager(child1, child2, 
     325                                requiredEqualityLevel); 
     326 
     327                if (equality == TaskEquality.IDENTICAL) { 
     328                        // two different selection instances can be at most lexically equal 
     329                        // even if their 
     330                        // children are identical 
     331                        return TaskEquality.LEXICALLY_EQUAL; 
     332                } else { 
     333                        return equality; 
     334                } 
     335        } 
     336 
     337        /** 
     338         * <p> 
     339         * determines the most concrete equality level for all tasks in the first 
     340         * list compared to all tasks in the second list. It is sufficient, if there 
     341         * is one task in one list for which there exist an equal task in the other 
     342         * list. 
     343         * </p> 
     344         * 
     345         * @param children1 
     346         *            the first list to be compared 
     347         * @param children2 
     348         *            the second list to be compared 
     349         *  
     350         * @return the most concrete task equality identified for all tasks in the 
     351         *         first list with respect to the second list 
     352         */ 
     353        private TaskEquality getMostConcreteEqualityLevel(List<ITask> children1, 
     354                        List<ITask> children2) { 
     355                TaskEquality childEquality; 
     356                TaskEquality currentEquality; 
     357                for (final ITask child1 : children1) { 
     358                        childEquality = null; 
     359                        for (final ITask child2 : children2) { 
     360                                currentEquality = callRuleManager(child1, child2, null); 
     361                                if ((currentEquality != null) 
     362                                                && (currentEquality != TaskEquality.UNEQUAL)) { 
     363                                        if (childEquality == null) { 
     364                                                childEquality = currentEquality; 
     365                                        } else { 
     366                                                childEquality = childEquality 
     367                                                                .getCommonDenominator(currentEquality); 
     368                                        } 
     369 
     370                                        if (childEquality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)) { 
     371                                                // as we calculate the most concrete equality, we can 
     372                                                // break up here 
     373                                                return TaskEquality.LEXICALLY_EQUAL; 
     374                                        } 
     375                                } 
     376                        } 
     377                } 
     378 
     379                // as the comparison should be commutative, we do not need to check, if 
     380                // in list 2 there is 
     381                // a child equal to one in list 1 
     382                return TaskEquality.UNEQUAL; 
     383        } 
     384 
     385        /* 
     386         * (non-Javadoc) 
     387         *  
     388         * @see TaskComparisonRule#isApplicable(ITask, ITask) 
     389         */ 
     390        @Override 
     391        public boolean isApplicable(ITask task1, ITask task2) { 
     392                return (task1 instanceof ISelection) && (task2 instanceof ISelection); 
     393        } 
     394 
     395        /* 
     396         * (non-Javadoc) 
     397         *  
     398         * @see TaskComparisonRule#isApplicable(ITaskInstance, ITaskInstance) 
     399         */ 
     400        @Override 
     401        public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2) { 
     402                return isApplicable(instance1.getTask(), instance2.getTask()); 
     403        } 
    347404} 
Note: See TracChangeset for help on using the changeset viewer.