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/temporalrelation/TaskInstanceComparator.java

    r1401 r1733  
    2727/** 
    2828 * <p> 
    29  * implementation of a symbol comparator for task instances. Internally, it uses comparison buffers 
    30  * to prevent comparing two tasks or task instances several times. It internally instantiates 
    31  * comparers being the implementation strategy of the comparisons required for a specific level 
    32  * of task equality. The comparers internally use the {@link TaskEqualityRuleManager} for 
    33  * performing comparisons. 
     29 * implementation of a symbol comparator for task instances. Internally, it uses 
     30 * comparison buffers to prevent comparing two tasks or task instances several 
     31 * times. It internally instantiates comparers being the implementation strategy 
     32 * of the comparisons required for a specific level of task equality. The 
     33 * comparers internally use the {@link TaskEqualityRuleManager} for performing 
     34 * comparisons. 
    3435 * </p> 
    3536 */ 
    3637public class TaskInstanceComparator implements SymbolComparator<ITaskInstance> { 
    37      
    38     /**  */ 
    39     private static final long serialVersionUID = 1L; 
    40      
    41     /** 
    42      * the maximum size of the internal buffer used for storing comparison results 
    43      */ 
    44     private static final int MAX_BUFFER_SIZE = 2 * 1024 * 1024; 
    45  
    46     /** 
    47      * the considered level of task equality 
    48      */ 
    49     private TaskEquality minimalTaskEquality; 
    50  
    51     /** 
    52      * the comparer used internally for comparing two tasks 
    53      */ 
    54     private transient Comparer comparer; 
    55  
    56     /** 
    57      * the comparer used for comparing two tasks on the lexical level 
    58      */ 
    59     private transient Comparer lexicalComparer; 
    60  
    61     /** 
    62      * internal buffer used for storing comparison results 
    63      */ 
    64     private transient HashMap<Long, Boolean> equalityBuffer = new HashMap<Long, Boolean>(); 
    65  
    66     /** 
    67      * internal buffer used for storing comparison results only for lexical comparisons 
    68      */ 
    69     private transient HashMap<Long, Boolean> lexicalEqualityBuffer; 
    70  
    71     /** 
    72      * <p> 
    73      * initializes the comparator with a considered task equality level 
    74      * </p> 
    75      *  
    76      * @param minimalTaskEquality the considered task equality level 
    77      */ 
    78     public TaskInstanceComparator(TaskEquality minimalTaskEquality) { 
    79         this.minimalTaskEquality = minimalTaskEquality; 
    80         init(); 
    81     } 
    82  
    83     /* (non-Javadoc) 
    84      * @see SymbolComparator#equals(Object, Object) 
    85      */ 
    86     @Override 
    87     public boolean equals(ITaskInstance taskInstance1, ITaskInstance taskInstance2) { 
    88         return equals(taskInstance1.getTask(), taskInstance2.getTask()); 
    89     }         
    90  
    91     /** 
    92      * <p> 
    93      * returns true, if this comparator considers the provided tasks as equal, false else 
    94      * </p> 
    95      *  
    96      * @param task1 the first task to compare 
    97      * @param task2 the second task to compare 
    98      *  
    99      * @return as described 
    100      */ 
    101     public boolean equals(ITask task1, ITask task2) { 
    102         Boolean result; 
    103          
    104         if (task1 != task2) { 
    105             //if ((task1 instanceof IEventTask) && (task2 instanceof IEventTask)) { 
    106                 long key = ((long) System.identityHashCode(task1)) << 32; 
    107                 key += System.identityHashCode(task2); 
    108              
    109                 result = equalityBuffer.get(key); 
    110              
    111                 if (result == null) { 
    112                     result = comparer.compare(task1, task2); 
    113                      
    114                     if (equalityBuffer.size() < MAX_BUFFER_SIZE) { 
    115                         equalityBuffer.put(key, result); 
    116                     } 
    117                 } 
    118             /*} 
    119             else { 
    120                 result = false; 
    121             }*/ 
    122         } 
    123         else { 
    124             result = true; 
    125         } 
    126          
    127         return result; 
    128     } 
    129  
    130     /** 
    131      * <p> 
    132      * returns true, if this comparator considers the provided tasks as lexically equal, false else 
    133      * </p> 
    134      *  
    135      * @param task1 the first task to compare 
    136      * @param task2 the second task to compare 
    137      *  
    138      * @return as described 
    139      */ 
    140     public boolean areLexicallyEqual(ITask task1, ITask task2) { 
    141         Boolean result; 
    142          
    143         if (task1 != task2) { 
    144             long key = ((long) System.identityHashCode(task1)) << 32; 
    145             key += System.identityHashCode(task2); 
    146              
    147             result = lexicalEqualityBuffer.get(key); 
    148              
    149             if (result == null) { 
    150                 result = lexicalComparer.compare(task1, task2); 
    151                 if (equalityBuffer.size() < MAX_BUFFER_SIZE) { 
    152                     lexicalEqualityBuffer.put(key, result); 
    153                 } 
    154             } 
    155         } 
    156         else { 
    157             result = true; 
    158         } 
    159          
    160         return result; 
    161     } 
    162      
    163     /** 
    164      * <p> 
    165      * can be called externally to clear the internal comparison buffers 
    166      * </p> 
    167      */ 
    168     public void clearBuffers() { 
    169         equalityBuffer.clear(); 
    170         init(); 
    171     } 
    172      
    173     /** 
    174      * <p> 
    175      * initializes the comparator with comparers depending on the different comparison levels as 
    176      * well as with the required comparison buffers. Comparers and buffers for lexical comparison 
    177      * may be reused if the considered equality level is also lexical. 
    178      * </p> 
    179      */ 
    180     private void init() { 
    181         if (minimalTaskEquality == TaskEquality.LEXICALLY_EQUAL) { 
    182             comparer = new LexicalComparer(); 
    183         } 
    184         else if (minimalTaskEquality == TaskEquality.SYNTACTICALLY_EQUAL) { 
    185             comparer = new SyntacticalComparer(); 
    186         } 
    187         else if (minimalTaskEquality == TaskEquality.SEMANTICALLY_EQUAL) { 
    188             comparer = new SemanticalComparer(); 
    189         } 
    190         else { 
    191             comparer = new DefaultComparer(this.minimalTaskEquality); 
    192         } 
    193          
    194         if (minimalTaskEquality == TaskEquality.LEXICALLY_EQUAL) { 
    195             lexicalComparer = comparer; 
    196             lexicalEqualityBuffer = equalityBuffer; 
    197         } 
    198         else { 
    199             lexicalComparer = new LexicalComparer(); 
    200             lexicalEqualityBuffer = new HashMap<Long, Boolean>(); 
    201         } 
    202     } 
    203      
    204     /** 
    205      * <p> 
    206      * deserialize this object and reinitialize the buffers 
    207      * </p> 
    208      */ 
    209     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { 
    210         in.defaultReadObject(); 
    211         init(); 
    212     } 
    213  
    214  
    215     /** 
    216      * <p> 
    217      * interface for internally used comparers containing only a compare method 
    218      * </p> 
    219      */ 
    220     private static interface Comparer { 
    221          
    222         /** 
    223          * <p> 
    224          * returns true, if this comparator considers the provided tasks as equal, false else 
    225          * </p> 
    226          *  
    227          * @param task1 the first task to compare 
    228          * @param task2 the second task to compare 
    229          *  
    230          * @return as described 
    231          */ 
    232         boolean compare(ITask task1, ITask task2); 
    233     } 
    234  
    235     /** 
    236      * <p> 
    237      * comparer that performs comparisons only on the lexical level 
    238      * </p> 
    239      */ 
    240     private static class LexicalComparer implements Comparer { 
    241          
    242         /* (non-Javadoc) 
    243          * @see Comparer#compare(ITask, ITask) 
    244          */ 
    245         public boolean compare(ITask task1, ITask task2) { 
    246             return TaskEqualityRuleManager.getInstance().areLexicallyEqual(task1, task2); 
    247         } 
    248     } 
    249  
    250     /** 
    251      * <p> 
    252      * comparer that performs comparisons only on the syntactical level 
    253      * </p> 
    254      *  
    255      */ 
    256     private static class SyntacticalComparer implements Comparer { 
    257          
    258         /* (non-Javadoc) 
    259          * @see Comparer#compare(ITask, ITask) 
    260          */ 
    261         public boolean compare(ITask task1, ITask task2) { 
    262             return TaskEqualityRuleManager.getInstance().areSyntacticallyEqual(task1, task2); 
    263         } 
    264     } 
    265  
    266     /** 
    267      * <p> 
    268      * comparer that performs comparisons only on the semantical level 
    269      * </p> 
    270      */ 
    271     private static class SemanticalComparer implements Comparer { 
    272          
    273         /* (non-Javadoc) 
    274          * @see Comparer#compare(ITask, ITask) 
    275          */ 
    276         public boolean compare(ITask task1, ITask task2) { 
    277             return TaskEqualityRuleManager.getInstance().areSemanticallyEqual(task1, task2); 
    278         } 
    279     } 
    280  
    281     /** 
    282      * <p> 
    283      * comparer that performs comparisons only on the provided level 
    284      * </p> 
    285      */ 
    286     private static class DefaultComparer implements Comparer { 
    287          
    288         /** 
    289          * <p> 
    290          * the minimal task equality considered by this comparer 
    291          * </p> 
    292          */ 
    293         private TaskEquality minimalTaskEquality; 
    294          
    295         /** 
    296          * <p> 
    297          * initializes this comparer with the task equality to be considered 
    298          * </p> 
    299          */ 
    300         public DefaultComparer(TaskEquality minimalTaskEquality) { 
    301            this.minimalTaskEquality = minimalTaskEquality; 
    302         } 
    303          
    304         /* (non-Javadoc) 
    305          * @see Comparer#compare(ITask, ITask) 
    306          */ 
    307         public boolean compare(ITask task1, ITask task2) { 
    308             return TaskEqualityRuleManager.getInstance().areAtLeastEqual 
    309                 (task1, task2, minimalTaskEquality); 
    310         } 
    311     } 
     38 
     39        /** 
     40         * <p> 
     41         * interface for internally used comparers containing only a compare method 
     42         * </p> 
     43         */ 
     44        private static interface Comparer { 
     45 
     46                /** 
     47                 * <p> 
     48                 * returns true, if this comparator considers the provided tasks as 
     49                 * equal, false else 
     50                 * </p> 
     51                 *  
     52                 * @param task1 
     53                 *            the first task to compare 
     54                 * @param task2 
     55                 *            the second task to compare 
     56                 *  
     57                 * @return as described 
     58                 */ 
     59                boolean compare(ITask task1, ITask task2); 
     60        } 
     61 
     62        /** 
     63         * <p> 
     64         * comparer that performs comparisons only on the provided level 
     65         * </p> 
     66         */ 
     67        private static class DefaultComparer implements Comparer { 
     68 
     69                /** 
     70                 * <p> 
     71                 * the minimal task equality considered by this comparer 
     72                 * </p> 
     73                 */ 
     74                private final TaskEquality minimalTaskEquality; 
     75 
     76                /** 
     77                 * <p> 
     78                 * initializes this comparer with the task equality to be considered 
     79                 * </p> 
     80                 */ 
     81                public DefaultComparer(TaskEquality minimalTaskEquality) { 
     82                        this.minimalTaskEquality = minimalTaskEquality; 
     83                } 
     84 
     85                /* 
     86                 * (non-Javadoc) 
     87                 *  
     88                 * @see Comparer#compare(ITask, ITask) 
     89                 */ 
     90                @Override 
     91                public boolean compare(ITask task1, ITask task2) { 
     92                        return TaskEqualityRuleManager.getInstance().areAtLeastEqual(task1, 
     93                                        task2, minimalTaskEquality); 
     94                } 
     95        } 
     96 
     97        /** 
     98         * <p> 
     99         * comparer that performs comparisons only on the lexical level 
     100         * </p> 
     101         */ 
     102        private static class LexicalComparer implements Comparer { 
     103 
     104                /* 
     105                 * (non-Javadoc) 
     106                 *  
     107                 * @see Comparer#compare(ITask, ITask) 
     108                 */ 
     109                @Override 
     110                public boolean compare(ITask task1, ITask task2) { 
     111                        return TaskEqualityRuleManager.getInstance().areLexicallyEqual( 
     112                                        task1, task2); 
     113                } 
     114        } 
     115 
     116        /** 
     117         * <p> 
     118         * comparer that performs comparisons only on the semantical level 
     119         * </p> 
     120         */ 
     121        private static class SemanticalComparer implements Comparer { 
     122 
     123                /* 
     124                 * (non-Javadoc) 
     125                 *  
     126                 * @see Comparer#compare(ITask, ITask) 
     127                 */ 
     128                @Override 
     129                public boolean compare(ITask task1, ITask task2) { 
     130                        return TaskEqualityRuleManager.getInstance().areSemanticallyEqual( 
     131                                        task1, task2); 
     132                } 
     133        } 
     134 
     135        /** 
     136         * <p> 
     137         * comparer that performs comparisons only on the syntactical level 
     138         * </p> 
     139         *  
     140         */ 
     141        private static class SyntacticalComparer implements Comparer { 
     142 
     143                /* 
     144                 * (non-Javadoc) 
     145                 *  
     146                 * @see Comparer#compare(ITask, ITask) 
     147                 */ 
     148                @Override 
     149                public boolean compare(ITask task1, ITask task2) { 
     150                        return TaskEqualityRuleManager.getInstance().areSyntacticallyEqual( 
     151                                        task1, task2); 
     152                } 
     153        } 
     154 
     155        /**  */ 
     156        private static final long serialVersionUID = 1L; 
     157 
     158        /** 
     159         * the maximum size of the internal buffer used for storing comparison 
     160         * results 
     161         */ 
     162        private static final int MAX_BUFFER_SIZE = 2 * 1024 * 1024; 
     163 
     164        /** 
     165         * the considered level of task equality 
     166         */ 
     167        private final TaskEquality minimalTaskEquality; 
     168 
     169        /** 
     170         * the comparer used internally for comparing two tasks 
     171         */ 
     172        private transient Comparer comparer; 
     173 
     174        /** 
     175         * the comparer used for comparing two tasks on the lexical level 
     176         */ 
     177        private transient Comparer lexicalComparer; 
     178 
     179        /** 
     180         * internal buffer used for storing comparison results 
     181         */ 
     182        private transient HashMap<Long, Boolean> equalityBuffer = new HashMap<Long, Boolean>(); 
     183 
     184        /** 
     185         * internal buffer used for storing comparison results only for lexical 
     186         * comparisons 
     187         */ 
     188        private transient HashMap<Long, Boolean> lexicalEqualityBuffer; 
     189 
     190        /** 
     191         * <p> 
     192         * initializes the comparator with a considered task equality level 
     193         * </p> 
     194         *  
     195         * @param minimalTaskEquality 
     196         *            the considered task equality level 
     197         */ 
     198        public TaskInstanceComparator(TaskEquality minimalTaskEquality) { 
     199                this.minimalTaskEquality = minimalTaskEquality; 
     200                init(); 
     201        } 
     202 
     203        /** 
     204         * <p> 
     205         * returns true, if this comparator considers the provided tasks as 
     206         * lexically equal, false else 
     207         * </p> 
     208         *  
     209         * @param task1 
     210         *            the first task to compare 
     211         * @param task2 
     212         *            the second task to compare 
     213         *  
     214         * @return as described 
     215         */ 
     216        public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     217                Boolean result; 
     218 
     219                if (task1 != task2) { 
     220                        long key = ((long) System.identityHashCode(task1)) << 32; 
     221                        key += System.identityHashCode(task2); 
     222 
     223                        result = lexicalEqualityBuffer.get(key); 
     224 
     225                        if (result == null) { 
     226                                result = lexicalComparer.compare(task1, task2); 
     227                                if (equalityBuffer.size() < MAX_BUFFER_SIZE) { 
     228                                        lexicalEqualityBuffer.put(key, result); 
     229                                } 
     230                        } 
     231                } else { 
     232                        result = true; 
     233                } 
     234 
     235                return result; 
     236        } 
     237 
     238        /** 
     239         * <p> 
     240         * can be called externally to clear the internal comparison buffers 
     241         * </p> 
     242         */ 
     243        public void clearBuffers() { 
     244                equalityBuffer.clear(); 
     245                init(); 
     246        } 
     247 
     248        /** 
     249         * <p> 
     250         * returns true, if this comparator considers the provided tasks as equal, 
     251         * false else 
     252         * </p> 
     253         *  
     254         * @param task1 
     255         *            the first task to compare 
     256         * @param task2 
     257         *            the second task to compare 
     258         *  
     259         * @return as described 
     260         */ 
     261        public boolean equals(ITask task1, ITask task2) { 
     262                Boolean result; 
     263 
     264                if (task1 != task2) { 
     265                        // if ((task1 instanceof IEventTask) && (task2 instanceof 
     266                        // IEventTask)) { 
     267                        long key = ((long) System.identityHashCode(task1)) << 32; 
     268                        key += System.identityHashCode(task2); 
     269 
     270                        result = equalityBuffer.get(key); 
     271 
     272                        if (result == null) { 
     273                                result = comparer.compare(task1, task2); 
     274 
     275                                if (equalityBuffer.size() < MAX_BUFFER_SIZE) { 
     276                                        equalityBuffer.put(key, result); 
     277                                } 
     278                        } 
     279                        /* 
     280                         * } else { result = false; } 
     281                         */ 
     282                } else { 
     283                        result = true; 
     284                } 
     285 
     286                return result; 
     287        } 
     288 
     289        /* 
     290         * (non-Javadoc) 
     291         *  
     292         * @see SymbolComparator#equals(Object, Object) 
     293         */ 
     294        @Override 
     295        public boolean equals(ITaskInstance taskInstance1, 
     296                        ITaskInstance taskInstance2) { 
     297                return equals(taskInstance1.getTask(), taskInstance2.getTask()); 
     298        } 
     299 
     300        /** 
     301         * <p> 
     302         * initializes the comparator with comparers depending on the different 
     303         * comparison levels as well as with the required comparison buffers. 
     304         * Comparers and buffers for lexical comparison may be reused if the 
     305         * considered equality level is also lexical. 
     306         * </p> 
     307         */ 
     308        private void init() { 
     309                if (minimalTaskEquality == TaskEquality.LEXICALLY_EQUAL) { 
     310                        comparer = new LexicalComparer(); 
     311                } else if (minimalTaskEquality == TaskEquality.SYNTACTICALLY_EQUAL) { 
     312                        comparer = new SyntacticalComparer(); 
     313                } else if (minimalTaskEquality == TaskEquality.SEMANTICALLY_EQUAL) { 
     314                        comparer = new SemanticalComparer(); 
     315                } else { 
     316                        comparer = new DefaultComparer(this.minimalTaskEquality); 
     317                } 
     318 
     319                if (minimalTaskEquality == TaskEquality.LEXICALLY_EQUAL) { 
     320                        lexicalComparer = comparer; 
     321                        lexicalEqualityBuffer = equalityBuffer; 
     322                } else { 
     323                        lexicalComparer = new LexicalComparer(); 
     324                        lexicalEqualityBuffer = new HashMap<Long, Boolean>(); 
     325                } 
     326        } 
     327 
     328        /** 
     329         * <p> 
     330         * deserialize this object and reinitialize the buffers 
     331         * </p> 
     332         */ 
     333        private void readObject(ObjectInputStream in) throws IOException, 
     334                        ClassNotFoundException { 
     335                in.defaultReadObject(); 
     336                init(); 
     337        } 
    312338 
    313339} 
Note: See TracChangeset for help on using the changeset viewer.