Ignore:
Timestamp:
02/26/14 17:12:53 (10 years ago)
Author:
pharms
Message:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1394 r1401  
    2626 
    2727/** 
    28  * TODO comment 
     28 * <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. 
     34 * </p> 
    2935 */ 
    3036public class TaskInstanceComparator implements SymbolComparator<ITaskInstance> { 
    … …  
    3339    private static final long serialVersionUID = 1L; 
    3440     
    35     /** */ 
     41    /** 
     42     * the maximum size of the internal buffer used for storing comparison results 
     43     */ 
    3644    private static final int MAX_BUFFER_SIZE = 2 * 1024 * 1024; 
    3745 
    38     /** */ 
    39     private TaskEquality minimalNodeEquality; 
    40  
    41     /** */ 
     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     */ 
    4254    private transient Comparer comparer; 
    4355 
    44     /** */ 
     56    /** 
     57     * the comparer used for comparing two tasks on the lexical level 
     58     */ 
    4559    private transient Comparer lexicalComparer; 
    4660 
    47     /** */ 
     61    /** 
     62     * internal buffer used for storing comparison results 
     63     */ 
    4864    private transient HashMap<Long, Boolean> equalityBuffer = new HashMap<Long, Boolean>(); 
    4965 
    50     /** */ 
     66    /** 
     67     * internal buffer used for storing comparison results only for lexical comparisons 
     68     */ 
    5169    private transient HashMap<Long, Boolean> lexicalEqualityBuffer; 
    5270 
    5371    /** 
    54      * 
    55      */ 
    56     public TaskInstanceComparator(TaskEquality minimalNodeEquality) { 
    57         this.minimalNodeEquality = minimalNodeEquality; 
     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; 
    5880        init(); 
    5981    } 
    … …  
    6890 
    6991    /** 
    70      *  
     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 
    71100     */ 
    72101    public boolean equals(ITask task1, ITask task2) { 
    … …  
    100129 
    101130    /** 
    102      * 
     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 
    103139     */ 
    104140    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
    … …  
    127163    /** 
    128164     * <p> 
    129      * TODO: comment 
    130      * </p> 
    131      * 
     165     * can be called externally to clear the internal comparison buffers 
     166     * </p> 
    132167     */ 
    133168    public void clearBuffers() { 
    … …  
    137172     
    138173    /** 
    139      *  
     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> 
    140179     */ 
    141180    private void init() { 
    142         if (minimalNodeEquality == TaskEquality.LEXICALLY_EQUAL) { 
     181        if (minimalTaskEquality == TaskEquality.LEXICALLY_EQUAL) { 
    143182            comparer = new LexicalComparer(); 
    144183        } 
    145         else if (minimalNodeEquality == TaskEquality.SYNTACTICALLY_EQUAL) { 
     184        else if (minimalTaskEquality == TaskEquality.SYNTACTICALLY_EQUAL) { 
    146185            comparer = new SyntacticalComparer(); 
    147186        } 
    148         else if (minimalNodeEquality == TaskEquality.SEMANTICALLY_EQUAL) { 
     187        else if (minimalTaskEquality == TaskEquality.SEMANTICALLY_EQUAL) { 
    149188            comparer = new SemanticalComparer(); 
    150189        } 
    151190        else { 
    152             comparer = new DefaultComparer(this.minimalNodeEquality); 
    153         } 
    154          
    155         if (minimalNodeEquality == TaskEquality.LEXICALLY_EQUAL) { 
     191            comparer = new DefaultComparer(this.minimalTaskEquality); 
     192        } 
     193         
     194        if (minimalTaskEquality == TaskEquality.LEXICALLY_EQUAL) { 
    156195            lexicalComparer = comparer; 
    157196            lexicalEqualityBuffer = equalityBuffer; 
    … …  
    175214 
    176215    /** 
    177      *  
     216     * <p> 
     217     * interface for internally used comparers containing only a compare method 
     218     * </p> 
    178219     */ 
    179220    private static interface Comparer { 
    180221         
    181222        /** 
     223         * <p> 
     224         * returns true, if this comparator considers the provided tasks as equal, false else 
     225         * </p> 
    182226         *  
     227         * @param task1 the first task to compare 
     228         * @param task2 the second task to compare 
     229         *  
     230         * @return as described 
    183231         */ 
    184232        boolean compare(ITask task1, ITask task2); 
    … …  
    186234 
    187235    /** 
    188      *  
     236     * <p> 
     237     * comparer that performs comparisons only on the lexical level 
     238     * </p> 
    189239     */ 
    190240    private static class LexicalComparer implements Comparer { 
    191241         
    192         /** 
    193          *  
     242        /* (non-Javadoc) 
     243         * @see Comparer#compare(ITask, ITask) 
    194244         */ 
    195245        public boolean compare(ITask task1, ITask task2) { 
    … …  
    199249 
    200250    /** 
     251     * <p> 
     252     * comparer that performs comparisons only on the syntactical level 
     253     * </p> 
    201254     *  
    202255     */ 
    203256    private static class SyntacticalComparer implements Comparer { 
    204257         
    205         /** 
    206          *  
     258        /* (non-Javadoc) 
     259         * @see Comparer#compare(ITask, ITask) 
    207260         */ 
    208261        public boolean compare(ITask task1, ITask task2) { 
    … …  
    212265 
    213266    /** 
    214      *  
     267     * <p> 
     268     * comparer that performs comparisons only on the semantical level 
     269     * </p> 
    215270     */ 
    216271    private static class SemanticalComparer implements Comparer { 
    217272         
    218         /** 
    219          *  
     273        /* (non-Javadoc) 
     274         * @see Comparer#compare(ITask, ITask) 
    220275         */ 
    221276        public boolean compare(ITask task1, ITask task2) { 
    … …  
    225280 
    226281    /** 
    227      *  
     282     * <p> 
     283     * comparer that performs comparisons only on the provided level 
     284     * </p> 
    228285     */ 
    229286    private static class DefaultComparer implements Comparer { 
    … …  
    231288        /** 
    232289         * <p> 
    233          * the minimal task equality two identified sublists need to have to consider them as equal 
     290         * the minimal task equality considered by this comparer 
    234291         * </p> 
    235292         */ 
    236         private TaskEquality minimalNodeEquality; 
     293        private TaskEquality minimalTaskEquality; 
    237294         
    238295        /** 
    239          * 
    240          */ 
    241         public DefaultComparer(TaskEquality minimalNodeEquality) { 
    242            this.minimalNodeEquality = minimalNodeEquality; 
    243         } 
    244          
    245         /** 
    246          *  
     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) 
    247306         */ 
    248307        public boolean compare(ITask task1, ITask task2) { 
    249308            return TaskEqualityRuleManager.getInstance().areAtLeastEqual 
    250                 (task1, task2, minimalNodeEquality); 
     309                (task1, task2, minimalTaskEquality); 
    251310        } 
    252311    } 
Note: See TracChangeset for help on using the changeset viewer.