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/TaskComparisonRule.java

    r1294 r1733  
    2020/** 
    2121 * <p> 
    22  * A task comparison rule is used by the {@link TaskEqualityRuleManager} to compare tasks and 
    23  * task instances with each other. It provides several methods to be called for a comparison. 
     22 * A task comparison rule is used by the {@link TaskEqualityRuleManager} to 
     23 * compare tasks and task instances with each other. It provides several methods 
     24 * to be called for a comparison. 
    2425 * </p> 
    2526 *  
    … …  
    2930public interface TaskComparisonRule { 
    3031 
    31     /** 
    32      * <p> 
    33      * checks if the rule is applicable for comparing the two provided tasks 
    34      * </p> 
    35      *  
    36      * @param task1 the first task to compare 
    37      * @param task2 the second task to compare 
    38      *  
    39      * @return true, if the rule is applicable, false else 
    40      */ 
    41     public boolean isApplicable(ITask task1, ITask task2); 
     32        /** 
     33         * <p> 
     34         * checks, if the provided tasks are lexically equal 
     35         * </p> 
     36         *  
     37         * @param task1 
     38         *            the first task to compare 
     39         * @param task2 
     40         *            the second task to compare 
     41         *  
     42         * @return true, if the tasks are equal, false else 
     43         */ 
     44        public boolean areLexicallyEqual(ITask task1, ITask task2); 
    4245 
    43     /** 
    44      * <p> 
    45      * checks, if the provided tasks are lexically equal 
    46      * </p> 
    47      *  
    48      * @param task1 the first task to compare 
    49      * @param task2 the second task to compare 
    50      *  
    51      * @return true, if the tasks are equal, false else 
    52      */ 
    53     public boolean areLexicallyEqual(ITask task1, ITask task2); 
     46        /** 
     47         * <p> 
     48         * checks, if the provided task instances are lexically equal 
     49         * </p> 
     50         *  
     51         * @param instance1 
     52         *            the first task instance to compare 
     53         * @param instance2 
     54         *            the second task instance to compare 
     55         *  
     56         * @return true, if the tasks are equal, false else 
     57         */ 
     58        public boolean areLexicallyEqual(ITaskInstance instance1, 
     59                        ITaskInstance instance2); 
    5460 
    55     /** 
    56      * <p> 
    57      * checks, if the provided tasks are syntactically equal 
    58      * </p> 
    59      *  
    60      * @param task1 the first task to compare 
    61      * @param task2 the second task to compare 
    62      *  
    63      * @return true, if the tasks are equal, false else 
    64      */ 
    65     public boolean areSyntacticallyEqual(ITask task1, ITask task2); 
     61        /** 
     62         * <p> 
     63         * checks, if the provided tasks are semantically equal 
     64         * </p> 
     65         *  
     66         * @param task1 
     67         *            the first task to compare 
     68         * @param task2 
     69         *            the second task to compare 
     70         *  
     71         * @return true, if the tasks are equal, false else 
     72         */ 
     73        public boolean areSemanticallyEqual(ITask task1, ITask task2); 
    6674 
    67     /** 
    68      * <p> 
    69      * checks, if the provided tasks are semantically equal 
    70      * </p> 
    71      *  
    72      * @param task1 the first task to compare 
    73      * @param task2 the second task to compare 
    74      *  
    75      * @return true, if the tasks are equal, false else 
    76      */ 
    77     public boolean areSemanticallyEqual(ITask task1, ITask task2); 
     75        /** 
     76         * <p> 
     77         * checks, if the provided task instances are semantically equal 
     78         * </p> 
     79         *  
     80         * @param instance1 
     81         *            the first task instance to compare 
     82         * @param instance2 
     83         *            the second task instance to compare 
     84         *  
     85         * @return true, if the tasks are equal, false else 
     86         */ 
     87        public boolean areSemanticallyEqual(ITaskInstance instance1, 
     88                        ITaskInstance instance2); 
    7889 
    79     /** 
    80     * <p> 
    81      * compares two tasks with each other. The result of the method is either a task equality or 
    82      * null. If it is null, it means, that the rule is not able to correctly compare the two given 
    83      * tasks 
    84      * </p> 
    85      *  
    86      * @param task1 the first task to compare 
    87      * @param task2 the second task to compare 
    88     *  
    89      * @return as described 
    90     */ 
    91     public TaskEquality compare(ITask task1, ITask task2); 
     90        /** 
     91        * <p> 
     92         * checks, if the provided tasks are syntactically equal 
     93         * </p> 
     94         *  
     95         * @param task1 
     96         *            the first task to compare 
     97         * @param task2 
     98         *            the second task to compare 
     99        *  
     100         * @return true, if the tasks are equal, false else 
     101        */ 
     102        public boolean areSyntacticallyEqual(ITask task1, ITask task2); 
    92103 
    93     /** 
    94      * <p> 
    95      * checks if the rule is applicable for comparing the two provided task instances 
    96      * </p> 
    97      *  
    98      * @param instance1 the first task instance to compare 
    99      * @param instance2 the second task instance to compare 
    100      *  
    101      * @return true, if the rule is applicable, false else 
    102      */ 
    103     public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2); 
     104        /** 
     105         * <p> 
     106         * checks, if the provided task instances are syntactically equal 
     107         * </p> 
     108         *  
     109         * @param instance1 
     110         *            the first task instance to compare 
     111         * @param instance2 
     112         *            the second task instance to compare 
     113         *  
     114         * @return true, if the tasks are equal, false else 
     115         */ 
     116        public boolean areSyntacticallyEqual(ITaskInstance instance1, 
     117                        ITaskInstance instance2); 
    104118 
    105     /** 
    106      * <p> 
    107      * checks, if the provided task instances are lexically equal 
    108      * </p> 
    109      *  
    110      * @param instance1 the first task instance to compare 
    111      * @param instance2 the second task instance to compare 
    112      *  
    113      * @return true, if the tasks are equal, false else 
    114      */ 
    115     public boolean areLexicallyEqual(ITaskInstance instance1, ITaskInstance instance2); 
     119        /** 
     120         * <p> 
     121         * compares two tasks with each other. The result of the method is either a 
     122         * task equality or null. If it is null, it means, that the rule is not able 
     123         * to correctly compare the two given tasks 
     124         * </p> 
     125         *  
     126         * @param task1 
     127         *            the first task to compare 
     128         * @param task2 
     129         *            the second task to compare 
     130         *  
     131         * @return as described 
     132         */ 
     133        public TaskEquality compare(ITask task1, ITask task2); 
    116134 
    117     /** 
    118      * <p> 
    119      * checks, if the provided task instances are syntactically equal 
    120      * </p> 
    121      *  
    122      * @param instance1 the first task instance to compare 
    123      * @param instance2 the second task instance to compare 
    124      *  
    125      * @return true, if the tasks are equal, false else 
    126      */ 
    127     public boolean areSyntacticallyEqual(ITaskInstance instance1, ITaskInstance instance2); 
     135        /** 
     136         * <p> 
     137         * compares two task instances with each other. The result of the method is 
     138         * either a task instance equality or null. If it is null, it means, that 
     139         * the rule is not able to correctly compare the two given task instances 
     140         * </p> 
     141         *  
     142         * @param instance1 
     143         *            the first task instance to compare 
     144         * @param instance2 
     145         *            the second task instance to compare 
     146         *  
     147         * @return as described 
     148         */ 
     149        public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2); 
    128150 
    129     /** 
    130      * <p> 
    131      * checks, if the provided task instances are semantically equal 
    132      * </p> 
    133      *  
    134      * @param instance1 the first task instance to compare 
    135      * @param instance2 the second task instance to compare 
    136      *  
    137      * @return true, if the tasks are equal, false else 
    138      */ 
    139     public boolean areSemanticallyEqual(ITaskInstance instance1, ITaskInstance instance2); 
     151        /** 
     152         * <p> 
     153         * checks if the rule is applicable for comparing the two provided tasks 
     154         * </p> 
     155         *  
     156         * @param task1 
     157         *            the first task to compare 
     158         * @param task2 
     159         *            the second task to compare 
     160         *  
     161         * @return true, if the rule is applicable, false else 
     162         */ 
     163        public boolean isApplicable(ITask task1, ITask task2); 
    140164 
    141     /** 
    142      * <p> 
    143      * compares two task instances with each other. The result of the method is either a task 
    144      * instance equality or null. If it is null, it means, that the rule is not able to correctly 
    145      * compare the two given task instances 
    146      * </p> 
    147      *  
    148      * @param instance1 the first task instance to compare 
    149      * @param instance2 the second task instance to compare 
    150      *  
    151      * @return as described 
    152      */ 
    153     public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2); 
     165        /** 
     166         * <p> 
     167         * checks if the rule is applicable for comparing the two provided task 
     168         * instances 
     169         * </p> 
     170         *  
     171         * @param instance1 
     172         *            the first task instance to compare 
     173         * @param instance2 
     174         *            the second task instance to compare 
     175         *  
     176         * @return true, if the rule is applicable, false else 
     177         */ 
     178        public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2); 
    154179 
    155180} 
Note: See TracChangeset for help on using the changeset viewer.