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

    r1294 r1733  
    2020/** 
    2121 * <p> 
    22  * This comparison rule returns <code>TaskEquality.IDENTICAL</code> if the comparison of the two 
    23  * tasks using the <code>==</code> operator returns true. Else it returns null to denote, that 
    24  * it can not compare the tasks. 
     22 * This comparison rule returns <code>TaskEquality.IDENTICAL</code> if the 
     23 * comparison of the two tasks using the <code>==</code> operator returns true. 
     24 * Else it returns null to denote, that it can not compare the tasks. 
    2525 * </p> 
    2626 *  
    … …  
    3030public class TaskIdentityRule implements TaskComparisonRule { 
    3131 
    32     /* (non-Javadoc) 
    33      * @see TaskComparisonRule#isApplicable(ITask, ITask) 
    34      */ 
    35     @Override 
    36     public boolean isApplicable(ITask task1, ITask task2) { 
    37         return (task1 == task2); 
    38     } 
     32        /* 
     33         * (non-Javadoc) 
     34         *  
     35         * @see TaskComparisonRule#areLexicallyEqual(ITask, ITask) 
     36         */ 
     37        @Override 
     38        public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     39                return (task1 == task2); 
     40        } 
    3941 
    40     /* (non-Javadoc) 
    41      * @see TaskComparisonRule#areLexicallyEqual(ITask, ITask) 
    42      */ 
    43     @Override 
    44     public boolean areLexicallyEqual(ITask task1, ITask task2) { 
    45         return (task1 == task2); 
    46     } 
     42        /* 
     43         * (non-Javadoc) 
     44         *  
     45         * @see TaskComparisonRule#areLexicallyEqual(ITaskInstance, ITaskInstance) 
     46         */ 
     47        @Override 
     48        public boolean areLexicallyEqual(ITaskInstance instance1, 
     49                        ITaskInstance instance2) { 
     50                return (instance1.getTask() == instance2.getTask()); 
     51        } 
    4752 
    48     /* (non-Javadoc) 
    49      * @see TaskComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    50      */ 
    51     @Override 
    52     public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
    53         return (task1 == task2); 
    54     } 
     53        /* 
     54         * (non-Javadoc) 
     55         *  
     56         * @see TaskComparisonRule#areSemanticallyEqual(ITask, ITask) 
     57         */ 
     58        @Override 
     59        public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     60                return (task1 == task2); 
     61        } 
    5562 
    56     /* (non-Javadoc) 
    57      * @see TaskComparisonRule#areSemanticallyEqual(ITask, ITask) 
    58      */ 
    59     @Override 
    60     public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
    61         return (task1 == task2); 
    62     } 
     63        /* 
     64         * (non-Javadoc) 
     65         *  
     66         * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance, 
     67         * ITaskInstance) 
     68         */ 
     69        @Override 
     70        public boolean areSemanticallyEqual(ITaskInstance instance1, 
     71                        ITaskInstance instance2) { 
     72                return (instance1.getTask() == instance2.getTask()); 
     73        } 
    6374 
    64     /* (non-Javadoc) 
    65      * @see TaskComparisonRule#compare(ITask, ITask) 
    66      */ 
    67     @Override 
    68     public TaskEquality compare(ITask task1, ITask task2) { 
    69         if (isApplicable(task1, task2)) { 
    70             return TaskEquality.IDENTICAL; 
    71         } 
    72         else { 
    73             return null; 
    74         } 
    75     } 
     75        /* 
     76         * (non-Javadoc) 
     77         *  
     78         * @see TaskComparisonRule#areSyntacticallyEqual(ITask, ITask) 
     79         */ 
     80        @Override 
     81        public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     82                return (task1 == task2); 
     83        } 
    7684 
    77     /* (non-Javadoc) 
    78      * @see TaskComparisonRule#isApplicable(ITaskInstance, ITaskInstance) 
    79      */ 
    80     @Override 
    81     public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2) { 
    82         return (instance1.getTask() == instance2.getTask()); 
    83     } 
     85        /* 
     86         * (non-Javadoc) 
     87         *  
     88         * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance, 
     89         * ITaskInstance) 
     90         */ 
     91        @Override 
     92        public boolean areSyntacticallyEqual(ITaskInstance instance1, 
     93                        ITaskInstance instance2) { 
     94                return (instance1.getTask() == instance2.getTask()); 
     95        } 
    8496 
    85     /* (non-Javadoc) 
    86      * @see TaskComparisonRule#areLexicallyEqual(ITaskInstance, ITaskInstance) 
    87      */ 
    88     @Override 
    89     public boolean areLexicallyEqual(ITaskInstance instance1, ITaskInstance instance2) { 
    90         return (instance1.getTask() == instance2.getTask()); 
    91     } 
     97        /* 
     98         * (non-Javadoc) 
     99         *  
     100         * @see TaskComparisonRule#compare(ITask, ITask) 
     101         */ 
     102        @Override 
     103        public TaskEquality compare(ITask task1, ITask task2) { 
     104                if (isApplicable(task1, task2)) { 
     105                        return TaskEquality.IDENTICAL; 
     106                } else { 
     107                        return null; 
     108                } 
     109        } 
    92110 
    93     /* (non-Javadoc) 
    94      * @see TaskComparisonRule#areSyntacticallyEqual(ITaskInstance, ITaskInstance) 
    95      */ 
    96     @Override 
    97     public boolean areSyntacticallyEqual(ITaskInstance instance1, ITaskInstance instance2) { 
    98         return (instance1.getTask() == instance2.getTask()); 
    99     } 
     111        /* 
     112         * (non-Javadoc) 
     113         *  
     114         * @see TaskComparisonRule#compare(ITaskInstance, ITaskInstance) 
     115         */ 
     116        @Override 
     117        public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2) { 
     118                if (isApplicable(instance1, instance2)) { 
     119                        return TaskEquality.IDENTICAL; 
     120                } else { 
     121                        return null; 
     122                } 
     123        } 
    100124 
    101     /* (non-Javadoc) 
    102      * @see TaskComparisonRule#areSemanticallyEqual(ITaskInstance, ITaskInstance) 
    103      */ 
    104     @Override 
    105     public boolean areSemanticallyEqual(ITaskInstance instance1, ITaskInstance instance2) { 
    106         return (instance1.getTask() == instance2.getTask()); 
    107     } 
     125        /* 
     126         * (non-Javadoc) 
     127         *  
     128         * @see TaskComparisonRule#isApplicable(ITask, ITask) 
     129         */ 
     130        @Override 
     131        public boolean isApplicable(ITask task1, ITask task2) { 
     132                return (task1 == task2); 
     133        } 
    108134 
    109     /* (non-Javadoc) 
    110      * @see TaskComparisonRule#compare(ITaskInstance, ITaskInstance) 
    111      */ 
    112     @Override 
    113     public TaskEquality compare(ITaskInstance instance1, ITaskInstance instance2) { 
    114         if (isApplicable(instance1, instance2)) { 
    115             return TaskEquality.IDENTICAL; 
    116         } 
    117         else { 
    118             return null; 
    119         } 
    120     } 
     135        /* 
     136         * (non-Javadoc) 
     137         *  
     138         * @see TaskComparisonRule#isApplicable(ITaskInstance, ITaskInstance) 
     139         */ 
     140        @Override 
     141        public boolean isApplicable(ITaskInstance instance1, ITaskInstance instance2) { 
     142                return (instance1.getTask() == instance2.getTask()); 
     143        } 
    121144 
    122145} 
Note: See TracChangeset for help on using the changeset viewer.