Le document suivant contient les résultats de PMD 5.2.1.
| Violation | Ligne |
|---|---|
| Avoid unused private methods such as 'load(IDashboardComponent,DAOUtil)'. | 328 |
| Avoid unused private methods such as 'setInsertOrUpdateValues(int,IDashboardComponent,DAOUtil)'. | 343 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 51 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 51 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 53–55 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 53–55 |
| Violation | Ligne |
|---|---|
| Avoid short class names like File | 46–163 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 85–110 |
| Violation | Ligne |
|---|---|
| A getX() method which returns a boolean should be named isX() | 86–89 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 96–110 |
| Avoid using Literals in Conditional Statements | 268 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 129–168 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 158 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 164 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 244 |
| Violation | Ligne |
|---|---|
| Private field '_listFilters' could be made final; it is only initialized in the declaration or constructor. | 55 |
| Use block level rather than method level synchronization | 60–68 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 94–107 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 66–68 |
| Avoid using Literals in Conditional Statements | 270 |
| Violation | Ligne |
|---|---|
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 64 |
| Violation | Ligne |
|---|---|
| This class has a bunch of public methods and attributes | 34–587 |
| Too many fields | 53–587 |
| Avoid short class names like Page | 53–587 |
| Use explicit scoping instead of the default package private level | 152–155 |
| Returning '_strImageContent' may expose an internal array. | 176 |
| The user-supplied array 'strImageContent' is stored directly. | 184 |
| These nested if statements could be combined | 439–442 |
| Do not add empty strings | 468 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 570 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 571 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 572 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 573 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 574 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 575 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 576 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=57, ATFD=204, TCC=0.0) | 34–806 |
| Avoid excessively long variable names like SQL_QUERY_SELECT_CHILD_PAGE_FOR_MODIFY_AUTORISATION_NODE | 98 |
| Use explicit scoping instead of the default package private level | 109–127 |
| Use block level rather than method level synchronization | 132–187 |
| Use explicit scoping instead of the default package private level | 400–417 |
| Use explicit scoping instead of the default package private level | 424–450 |
| Violation | Ligne |
|---|---|
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 64 |
| Violation | Ligne |
|---|---|
| Returning '_byValue' may expose an internal array. | 74 |
| The user-supplied array 'value' is stored directly. | 81 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 81–92 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 62–71 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 56–59 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 60–71 |
| Avoid variables with short names like r | 111 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 51 |
| Possible unsafe assignment to a non-final static field in a constructor. | 51 |
| It is a good practice to call super() in a constructor | 56–62 |
| Singleton is not thread safe | 84–87 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=60, ATFD=21, TCC=0.01942645698427382) | 34–677 |
| This class has a bunch of public methods and attributes | 34–677 |
| Abstract classes should be named AbstractXXX | 53–677 |
| Too many fields | 53–677 |
| The method addPortletTags() has an NPath complexity of 625 | 502–532 |
| An empty method in an abstract class should be abstract instead | 601–604 |
| An empty method in an abstract class should be abstract instead | 633–636 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 52–343 |
| Avoid variables with short names like p | 73 |
| Use explicit scoping instead of the default package private level | 126–129 |
| Use block level rather than method level synchronization | 158–177 |
| Use explicit scoping instead of the default package private level | 184–187 |
| Use block level rather than method level synchronization | 194–204 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 44–81 |
| An empty method in an abstract class should be abstract instead | 57–61 |
| An empty method in an abstract class should be abstract instead | 67–71 |
| Violation | Ligne |
|---|---|
| Do not add empty strings | 216 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 71 |
| This statement may have some unnecessary parentheses | 88 |
| This statement may have some unnecessary parentheses | 215 |
| This statement may have some unnecessary parentheses | 238 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 47–51 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 47–51 |
| Violation | Ligne |
|---|---|
| Avoid short class names like RBAC | 53–241 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 67–85 |
| Use block level rather than method level synchronization | 92–105 |
| Violation | Ligne |
|---|---|
| Private field '_aFeaturesList' could be made final; it is only initialized in the declaration or constructor. | 58 |
| Violation | Ligne |
|---|---|
| Do not add empty strings | 56 |
| Violation | Ligne |
|---|---|
| The class 'FeatureGroupHome' has a Cyclomatic Complexity of 3 (Highest = 10). | 44–211 |
| The method 'changeRightOrder' has a Cyclomatic Complexity of 10. | 173–210 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 62–80 |
| Use block level rather than method level synchronization | 86–96 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like o | 302 |
| Avoid variables with short names like o | 322 |
| Violation | Ligne |
|---|---|
| The class 'RightHome' has a Cyclomatic Complexity of 3 (Highest = 10). | 44–286 |
| The method 'changeRightOrder' has a Cyclomatic Complexity of 10. | 182–217 |
| Violation | Ligne |
|---|---|
| Avoid short class names like Role | 43–121 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 41–214 |
| An empty method in an abstract class should be abstract instead | 198–201 |
| An empty method in an abstract class should be abstract instead | 210–213 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 89 |
| Violation | Ligne |
|---|---|
| Avoid short class names like Mode | 40–230 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 70–88 |
| Use block level rather than method level synchronization | 94–113 |
| Violation | Ligne |
|---|---|
| The class 'ModeHome' has a Cyclomatic Complexity of 3 (Highest = 15). | 48–192 |
| The method getOuputXslProperties() has an NPath complexity of 2187 | 136–191 |
| The method 'getOuputXslProperties' has a Cyclomatic Complexity of 15. | 136–191 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 64–82 |
| Use block level rather than method level synchronization | 88–101 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 66–82 |
| Violation | Ligne |
|---|---|
| Returning '_strSource' may expose an internal array. | 158 |
| The user-supplied array 'strSource' is stored directly. | 166 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 73–91 |
| Use block level rather than method level synchronization | 97–113 |
| Prefer StringBuffer over += for concatenating strings | 177 |
| This statement may have some unnecessary parentheses | 293 |
| This statement may have some unnecessary parentheses | 319 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=57, ATFD=6, TCC=0.03145235892691952) | 34–573 |
| This class has a bunch of public methods and attributes | 34–573 |
| Too many fields | 58–573 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 86 |
| Private field '_rights' could be made final; it is only initialized in the declaration or constructor. | 86 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 86 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 92 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 92 |
| Private field '_roles' could be made final; it is only initialized in the declaration or constructor. | 92 |
| Document empty constructor | 106–108 |
| Use block level rather than method level synchronization | 124–131 |
| A getX() method which returns a boolean should be named isX() | 529–532 |
| Violation | Ligne |
|---|---|
| This class has a bunch of public methods and attributes | 34–1298 |
| Possible God class (WMC=103, ATFD=247, TCC=0.004625346901017576) | 34–1298 |
| Avoid really long classes. | 57–1298 |
| This class has too many methods, consider refactoring it. | 58–1298 |
| Use block level rather than method level synchronization | 301–329 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 373 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 431 |
| Prefer StringBuffer over += for concatenating strings | 833 |
| Prefer StringBuffer over += for concatenating strings | 838 |
| Prefer StringBuffer over += for concatenating strings | 841 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1033 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 1180 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 1210 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 1239 |
| Violation | Ligne |
|---|---|
| Avoid unused private fields such as 'PARAMETER_SEARCH_FIRST_NAME'. | 66 |
| Perhaps '_strFirstName' could be replaced by a local variable. | 76 |
| Avoid unused private fields such as '_strFirstName'. | 76 |
| Avoid unnecessary constructors - the compiler will generate these for you | 84–86 |
| Document empty constructor | 84–86 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 269 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 270 |
| Violation | Ligne |
|---|---|
| This class has a bunch of public methods and attributes | 34–505 |
| Violation | Ligne |
|---|---|
| This class has a bunch of public methods and attributes | 34–372 |
| This class has too many methods, consider refactoring it. | 52–372 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 75–77 |
| Avoid unnecessary constructors - the compiler will generate these for you | 75–77 |
| A getX() method which returns a boolean should be named isX() | 224–227 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 247 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 263 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 280 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 313 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=48, ATFD=112, TCC=0.01818181818181818) | 34–618 |
| The class 'AdminUserFieldDAO' has a Modified Cyclomatic Complexity of 4 (Highest = 15). | 51–618 |
| The class 'AdminUserFieldDAO' has a Cyclomatic Complexity of 4 (Highest = 15). | 51–618 |
| The class 'AdminUserFieldDAO' has a Standard Cyclomatic Complexity of 4 (Highest = 15). | 51–618 |
| Avoid excessively long variable names like SQL_QUERY_SELECT_USER_FIELDS_BY_ID_USER_ID_ATTRIBUTE | 69 |
| The method selectUsersByFilter() has an NPath complexity of 264 | 400–469 |
| The method 'selectUsersByFilter' has a Cyclomatic Complexity of 12. | 400–469 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 404 |
| Avoid using Literals in Conditional Statements | 414 |
| The method 'selectByFilter' has a Standard Cyclomatic Complexity of 15. | 478–617 |
| The method 'selectByFilter' has a Modified Cyclomatic Complexity of 15. | 478–617 |
| The method 'selectByFilter' has a Cyclomatic Complexity of 15. | 478–617 |
| The method selectByFilter() has an NPath complexity of 2304 | 478–617 |
| Avoid really long methods. | 478–617 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 500 |
| Violation | Ligne |
|---|---|
| Avoid unnecessary constructors - the compiler will generate these for you | 85–87 |
| Document empty constructor | 85–87 |
| It is a good practice to call super() in a constructor | 85–87 |
| Assigning an Object to null is a code smell. Consider refactoring. | 169 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 85–87 |
| Avoid unnecessary constructors - the compiler will generate these for you | 85–87 |
| It is a good practice to call super() in a constructor | 85–87 |
| Assigning an Object to null is a code smell. Consider refactoring. | 169 |
| Violation | Ligne |
|---|---|
| The class 'AttributeImage' has a Cyclomatic Complexity of 3 (Highest = 13). | 71–362 |
| It is a good practice to call super() in a constructor | 104–107 |
| The method 'setAttributeData' has a Cyclomatic Complexity of 13. | 185–251 |
| The method setAttributeData() has an NPath complexity of 505 | 185–251 |
| Assigning an Object to null is a code smell. Consider refactoring. | 189 |
| The method 'getUserFieldsData' has a Cyclomatic Complexity of 11. | 274–351 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 85–87 |
| Document empty constructor | 85–87 |
| Avoid unnecessary constructors - the compiler will generate these for you | 85–87 |
| Assigning an Object to null is a code smell. Consider refactoring. | 169 |
| Violation | Ligne |
|---|---|
| The class 'AttributeText' has a Cyclomatic Complexity of 2 (Highest = 10). | 56–316 |
| Document empty constructor | 90–92 |
| Avoid unnecessary constructors - the compiler will generate these for you | 90–92 |
| It is a good practice to call super() in a constructor | 90–92 |
| The method 'setAttributeData' has a Cyclomatic Complexity of 10. | 170–237 |
| Assigning an Object to null is a code smell. Consider refactoring. | 174 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 188 |
| Violation | Ligne |
|---|---|
| A getX() method which returns a boolean should be named isX() | 186 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 53–160 |
| Violation | Ligne |
|---|---|
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 138 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 139 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 142 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 144 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 146 |
| Avoid throwing raw exception types. | 178 |
| New exception is thrown in catch block, original stack trace may be lost | 195 |
| Avoid throwing raw exception types. | 214 |
| Avoid variables with short names like sb | 232 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 233 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 234 |
| Abstract classes should be named AbstractXXX | 271–294 |
| It is a good practice to call super() in a constructor | 309–312 |
| It is a good practice to call super() in a constructor | 337–349 |
| Violation | Ligne |
|---|---|
| Avoid unnecessary constructors - the compiler will generate these for you | 69–71 |
| Document empty constructor | 69–71 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 89–113 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 241 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 52–55 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 83–92 |
| New exception is thrown in catch block, original stack trace may be lost | 187 |
| New exception is thrown in catch block, original stack trace may be lost | 191 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=155, ATFD=175, TCC=0.06825396825396825) | 34–1556 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–1556 |
| The class 'AdminUserService' has a Modified Cyclomatic Complexity of 4 (Highest = 16). | 101–1556 |
| The class 'AdminUserService' has a Cyclomatic Complexity of 4 (Highest = 22). | 101–1556 |
| The class 'AdminUserService' has a Standard Cyclomatic Complexity of 4 (Highest = 16). | 101–1556 |
| Avoid really long classes. | 101–1556 |
| Avoid excessively long variable names like PROPERTY_MESSAGE_PASSWORD_FORMAT_SPECIAL_CHARACTERS | 193 |
| The method getFilteredUsersInterface() has an NPath complexity of 260 | 310–398 |
| The method 'getFilteredUsersInterface' has a Modified Cyclomatic Complexity of 11. | 310–398 |
| The method 'getFilteredUsersInterface' has a Cyclomatic Complexity of 13. | 310–398 |
| The method 'getFilteredUsersInterface' has a Standard Cyclomatic Complexity of 11. | 310–398 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 366 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 407 |
| The method 'checkEmail' has a Cyclomatic Complexity of 13. | 489–539 |
| The method 'checkEmail' has a Modified Cyclomatic Complexity of 10. | 489–539 |
| The method 'checkEmail' has a Standard Cyclomatic Complexity of 10. | 489–539 |
| An operation on an Immutable object (String, BigDecimal or BigInteger) wont change the object itself | 596 |
| An operation on an Immutable object (String, BigDecimal or BigInteger) wont change the object itself | 651 |
| An operation on an Immutable object (String, BigDecimal or BigInteger) wont change the object itself | 694 |
| An operation on an Immutable object (String, BigDecimal or BigInteger) wont change the object itself | 771 |
| An operation on an Immutable object (String, BigDecimal or BigInteger) wont change the object itself | 815 |
| Assigning an Object to null is a code smell. Consider refactoring. | 906 |
| The method 'checkPassword' has a Modified Cyclomatic Complexity of 16. | 965–1076 |
| The method checkPassword() has an NPath complexity of 3108 | 965–1076 |
| Avoid really long methods. | 965–1076 |
| The method 'checkPassword' has a Cyclomatic Complexity of 22. | 965–1076 |
| The method 'checkPassword' has a Standard Cyclomatic Complexity of 16. | 965–1076 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 1059 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 1290 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1305 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 1351 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1358 |
| The method getXmlFromUser() has an NPath complexity of 1296 | 1433–1554 |
| Avoid really long methods. | 1433–1554 |
| The method 'getXmlFromUser' has a Cyclomatic Complexity of 15. | 1433–1554 |
| The method 'getXmlFromUser' has a Standard Cyclomatic Complexity of 15. | 1433–1554 |
| The method 'getXmlFromUser' has a Modified Cyclomatic Complexity of 15. | 1433–1554 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–519 |
| Possible God class (WMC=50, ATFD=66, TCC=0.06666666666666667) | 34–519 |
| The class 'ImportAdminUserService' has a Standard Cyclomatic Complexity of 8 (Highest = 33). | 77–519 |
| The class 'ImportAdminUserService' has a Modified Cyclomatic Complexity of 8 (Highest = 33). | 77–519 |
| The class 'ImportAdminUserService' has a Cyclomatic Complexity of 8 (Highest = 37). | 77–519 |
| The method 'readLineOfCSVFile' has a Standard Cyclomatic Complexity of 33. | 102–411 |
| The method 'readLineOfCSVFile' has a Modified Cyclomatic Complexity of 33. | 102–411 |
| The method readLineOfCSVFile() has an NPath complexity of 2721600 | 102–411 |
| Avoid really long methods. | 102–411 |
| The method readLineOfCSVFile() has an NCSS line count of 163 | 102–411 |
| The method 'readLineOfCSVFile' has a Cyclomatic Complexity of 37. | 102–411 |
| Assigning an Object to null is a code smell. Consider refactoring. | 196 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 263 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 340 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 395 |
| A getX() method which returns a boolean should be named isX() | 505–508 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 53–56 |
| Violation | Ligne |
|---|---|
| Private field '_logger' could be made final; it is only initialized in the declaration or constructor. | 57 |
| The Logger variable declaration does not contain the static and final modifiers | 57 |
| clone() method should be implemented only if implementing Cloneable interface | 255–259 |
| clone() method should throw CloneNotSupportedException | 256–259 |
| clone() method should be implemented only if implementing Cloneable interface | 256 |
| Avoid throwing raw exception types. | 258 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 269 |
| An empty method in an abstract class should be abstract instead | 276–280 |
| An empty method in an abstract class should be abstract instead | 286–289 |
| An empty method in an abstract class should be abstract instead | 295–298 |
| An empty method in an abstract class should be abstract instead | 304–308 |
| An empty method in an abstract class should be abstract instead | 314–318 |
| An empty method in an abstract class should be abstract instead | 324–327 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 123–132 |
| Avoid variables with short names like cs | 214 |
| Avoid variables with short names like cs | 224 |
| Use explicit scoping instead of the default package private level | 260–283 |
| StringBuffer constructor is initialized with size 16, but has at least 27 characters appended. | 262 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 263–264 |
| Avoid appending characters as strings in StringBuffer.append. | 263 |
| Avoid appending characters as strings in StringBuffer.append. | 264 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 265–266 |
| Avoid appending characters as strings in StringBuffer.append. | 265 |
| Avoid appending characters as strings in StringBuffer.append. | 266 |
| Avoid appending characters as strings in StringBuffer.append. | 267 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 267–268 |
| Avoid appending characters as strings in StringBuffer.append. | 268 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 269–270 |
| Avoid appending characters as strings in StringBuffer.append. | 269 |
| Avoid appending characters as strings in StringBuffer.append. | 270 |
| Avoid appending characters as strings in StringBuffer.append. | 271 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 271–272 |
| Avoid appending characters as strings in StringBuffer.append. | 272 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 273–274 |
| Avoid appending characters as strings in StringBuffer.append. | 273 |
| Avoid appending characters as strings in StringBuffer.append. | 274 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 275–276 |
| Avoid appending characters as strings in StringBuffer.append. | 275 |
| Avoid appending characters as strings in StringBuffer.append. | 276 |
| Avoid appending characters as strings in StringBuffer.append. | 277 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 277–278 |
| Avoid appending characters as strings in StringBuffer.append. | 278 |
| Avoid appending characters as strings in StringBuffer.append. | 280 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 337 |
| Avoid variables with short names like cs | 361 |
| Avoid variables with short names like cs | 373 |
| This statement may have some unnecessary parentheses | 510 |
| Violation | Ligne |
|---|---|
| Avoid appending characters as strings in StringBuffer.append. | 70 |
| Avoid appending characters as strings in StringBuffer.append. | 70 |
| Avoid appending characters as strings in StringBuffer.append. | 70 |
| Avoid appending characters as strings in StringBuffer.append. | 76 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 76 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 76 |
| Avoid appending characters as strings in StringBuffer.append. | 77 |
| Violation | Ligne |
|---|---|
| Private field '_logger' could be made final; it is only initialized in the declaration or constructor. | 71 |
| The Logger variable declaration does not contain the static and final modifiers | 71 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 101 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 173 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 173 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 183 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 46–90 |
| Violation | Ligne |
|---|---|
| The class 'XPageAppService' has a Cyclomatic Complexity of 3 (Highest = 11). | 73–367 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 79 |
| The String literal "Error instantiating XPageApplication : " appears 5 times in this file; the first occurrence is on line 97 | 97 |
| The String literal " - " appears 4 times in this file; the first occurrence is on line 114 | 114 |
| Document empty method | 165–166 |
| Document empty method | 184–185 |
| The method 'getPage' has a Cyclomatic Complexity of 11. | 208–295 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 222 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 332 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 359 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 51–53 |
| Avoid variables with short names like o | 149 |
| Deeply nested if..then statements are hard to read | 160–163 |
| Avoid variables with short names like o | 188 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=81, ATFD=43, TCC=0.0) | 34–783 |
| The class 'CSVReaderService' has a Standard Cyclomatic Complexity of 4 (Highest = 35). | 68–783 |
| The class 'CSVReaderService' has a Cyclomatic Complexity of 5 (Highest = 40). | 68–783 |
| Abstract classes should be named AbstractXXX | 68–783 |
| The class 'CSVReaderService' has a Modified Cyclomatic Complexity of 4 (Highest = 35). | 68–783 |
| The method readCSVFile() has an NCSS line count of 112 | 368–638 |
| The method 'readCSVFile' has a Cyclomatic Complexity of 40. | 368–638 |
| The method 'readCSVFile' has a Standard Cyclomatic Complexity of 35. | 368–638 |
| The method 'readCSVFile' has a Modified Cyclomatic Complexity of 35. | 368–638 |
| Avoid really long methods. | 368–638 |
| The method readCSVFile() has an NPath complexity of 4289040 | 368–638 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 458 |
| These nested if statements could be combined | 460–477 |
| Deeply nested if..then statements are hard to read | 460–477 |
| Assigning an Object to null is a code smell. Consider refactoring. | 505 |
| Assigning an Object to null is a code smell. Consider refactoring. | 517 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 546 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 548 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 559 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 571 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 589 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 630 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 667 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 676 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 770 |
| Violation | Ligne |
|---|---|
| The class 'AccountLifeTimeDaemon' has a Cyclomatic Complexity of 18 (Highest = 34). | 65–378 |
| The class 'AccountLifeTimeDaemon' has a Modified Cyclomatic Complexity of 14 (Highest = 26). | 65–378 |
| The class 'AccountLifeTimeDaemon' has a Standard Cyclomatic Complexity of 14 (Highest = 26). | 65–378 |
| The method run() has an NCSS line count of 139 | 95–351 |
| The method run() has an NPath complexity of 14679168 | 95–351 |
| The method 'run' has a Cyclomatic Complexity of 34. | 95–351 |
| Avoid really long methods. | 95–351 |
| The method 'run' has a Modified Cyclomatic Complexity of 26. | 95–351 |
| The method 'run' has a Standard Cyclomatic Complexity of 26. | 95–351 |
| StringBuffer constructor is initialized with size 16, but has at least 222 characters appended. | 98 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 100 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 104 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 125 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 133 |
| The String literal "AccountLifeTimeDaemon - " appears 4 times in this file; the first occurrence is on line 143 | 143 |
| Avoid appending characters as strings in StringBuffer.append. | 148 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 171 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 192 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 201 |
| Avoid appending characters as strings in StringBuffer.append. | 216 |
| Assigning an Object to null is a code smell. Consider refactoring. | 218 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 242 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 263 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 272 |
| Assigning an Object to null is a code smell. Consider refactoring. | 288 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 302 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 317 |
| Avoid appending characters as strings in StringBuffer.append. | 336 |
| Violation | Ligne |
|---|---|
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 63 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 69 |
| Use block level rather than method level synchronization | 87–131 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 95 |
| Avoid instantiating Long objects.Call Long.valueOf() instead | 241 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 295–306 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 40–121 |
| Violation | Ligne |
|---|---|
| Private field '_thread' could be made final; it is only initialized in the declaration or constructor. | 56 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 166–169 |
| Violation | Ligne |
|---|---|
| Private field '_entry' could be made final; it is only initialized in the declaration or constructor. | 47 |
| A catch statement should never catch throwable since it includes errors. | 95 |
| Violation | Ligne |
|---|---|
| Private field '_runnable' could be made final; it is only initialized in the declaration or constructor. | 46 |
| Private field '_strKey' could be made final; it is only initialized in the declaration or constructor. | 47 |
| Private field '_plugin' could be made final; it is only initialized in the declaration or constructor. | 48 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 75 |
| Violation | Ligne |
|---|---|
| The class 'ThreadLauncherDaemon' has a Cyclomatic Complexity of 4 (Highest = 15). | 51–213 |
| The class 'ThreadLauncherDaemon' has a Modified Cyclomatic Complexity of 4 (Highest = 13). | 51–213 |
| The class 'ThreadLauncherDaemon' has a Standard Cyclomatic Complexity of 4 (Highest = 13). | 51–213 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 55 |
| Private field '_mapThreadByKey' could be made final; it is only initialized in the declaration or constructor. | 55 |
| Private field '_listThread' could be made final; it is only initialized in the declaration or constructor. | 56 |
| The method 'run' has a Standard Cyclomatic Complexity of 13. | 62–161 |
| The method run() has an NPath complexity of 1008 | 62–161 |
| The method 'run' has a Modified Cyclomatic Complexity of 13. | 62–161 |
| The method 'run' has a Cyclomatic Complexity of 15. | 62–161 |
| Use block level rather than method level synchronization | 186–189 |
| Use block level rather than method level synchronization | 195–203 |
| Use block level rather than method level synchronization | 209–212 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 45–217 |
| Avoid variables with short names like o | 165 |
| Violation | Ligne |
|---|---|
| Private field '_listRegisteredListeners' could be made final; it is only initialized in the declaration or constructor. | 52 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=61, ATFD=46, TCC=0.025) | 34–511 |
| The class 'DashboardService' has a Cyclomatic Complexity of 3 (Highest = 17). | 59–511 |
| The class 'DashboardService' has a Standard Cyclomatic Complexity of 3 (Highest = 13). | 59–511 |
| The class 'DashboardService' has a Modified Cyclomatic Complexity of 3 (Highest = 13). | 59–511 |
| Avoid variables with short names like dc | 130 |
| The method 'doMoveDashboard' has a Cyclomatic Complexity of 17. | 169–252 |
| The method 'doMoveDashboard' has a Modified Cyclomatic Complexity of 13. | 169–252 |
| The method 'doMoveDashboard' has a Standard Cyclomatic Complexity of 13. | 169–252 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 283 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 420 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 478 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 44–46 |
| No abstract method which means that the keyword is most likely used to prevent instantiation. Use a private or protected constructor instead. | 44–46 |
| Violation | Ligne |
|---|---|
| The class 'AdminDashboardService' has a Cyclomatic Complexity of 3 (Highest = 17). | 59–380 |
| The class 'AdminDashboardService' has a Standard Cyclomatic Complexity of 3 (Highest = 11). | 59–380 |
| The class 'AdminDashboardService' has a Modified Cyclomatic Complexity of 3 (Highest = 11). | 59–380 |
| Avoid variables with short names like dc | 129 |
| The method 'doMoveDashboard' has a Standard Cyclomatic Complexity of 11. | 168–245 |
| The method 'doMoveDashboard' has a Modified Cyclomatic Complexity of 11. | 168–245 |
| The method 'doMoveDashboard' has a Cyclomatic Complexity of 17. | 168–245 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 275 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 348 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like is | 80 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 85 |
| Avoid throwing raw exception types. | 100 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 66 |
| Private field '_logger' could be made final; it is only initialized in the declaration or constructor. | 66 |
| It is a good practice to call super() in a constructor | 73–76 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 117 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 127 |
| Document empty method | 181–182 |
| Avoid prefixing parameters by in, out or inOut. Uses Javadoc to document this behavior. | 185 |
| Document empty method | 186–187 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 59 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 47–50 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=47, ATFD=9, TCC=0.18382352941176472) | 34–439 |
| Use explicit scoping instead of the default package private level | 59 |
| Deeply nested if..then statements are hard to read | 102–105 |
| Deeply nested if..then statements are hard to read | 107–110 |
| Avoid variables with short names like p | 150 |
| Avoid variables with short names like sb | 323 |
| Avoid variables with short names like e | 415 |
| Avoid appending characters as strings in StringBuffer.append. | 432 |
| Violation | Ligne |
|---|---|
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_OPEN_SUBST_WITH_PARAM | 58 |
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_CLOSE_SUBST_WITH_PARAM | 59 |
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_OPEN_SUBST_WITHOUT_PARAM | 60 |
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_CLOSE_SUBST_WITHOUT_PARAM | 61 |
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_INTERNAL_SUBST | 62 |
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_PROCESS_INTERNAL_TAGS | 63 |
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_ACCEPT_PARAM | 64 |
| Avoid excessively long variable names like CONSTANT_EDITOR_BBCODE_COMPLEX_ELEMENT_REQUIRES_QUOTED_PARAM | 65 |
| Use of modifier volatile is not recommended. | 73 |
| Singleton is not thread safe | 92–100 |
| Violation | Ligne |
|---|---|
| Avoid unnecessary constructors - the compiler will generate these for you | 63–66 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 65–68 |
| Assigning an Object to null is a code smell. Consider refactoring. | 97 |
| Violation | Ligne |
|---|---|
| Assigning an Object to null is a code smell. Consider refactoring. | 72 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 49 |
| Private field '_mapInitParameters' could be made final; it is only initialized in the declaration or constructor. | 49 |
| Violation | Ligne |
|---|---|
| Private field '_listFilters' could be made final; it is only initialized in the declaration or constructor. | 55 |
| Avoid variables with short names like f | 83 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 143 |
| Violation | Ligne |
|---|---|
| Private field '_mapInitParameters' could be made final; it is only initialized in the declaration or constructor. | 54 |
| Avoid variables with short names like o | 212 |
| Violation | Ligne |
|---|---|
| Private field '_strName' could be made final; it is only initialized in the declaration or constructor. | 49 |
| Private field '_context' could be made final; it is only initialized in the declaration or constructor. | 50 |
| Private field '_mapInitParameters' could be made final; it is only initialized in the declaration or constructor. | 51 |
| Violation | Ligne |
|---|---|
| The class 'MainFilter' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 54–206 |
| The class 'MainFilter' has a Cyclomatic Complexity of 5 (Highest = 13). | 54–206 |
| The class 'MainFilter' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 54–206 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 78 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 101 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 129 |
| Use explicit scoping instead of the default package private level | 142–145 |
| The method 'matchFilterUrl' has a Modified Cyclomatic Complexity of 10. | 156–205 |
| Use explicit scoping instead of the default package private level | 156–205 |
| The method matchFilterUrl() has an NPath complexity of 240 | 156–205 |
| The method 'matchFilterUrl' has a Standard Cyclomatic Complexity of 10. | 156–205 |
| The method 'matchFilterUrl' has a Cyclomatic Complexity of 13. | 156–205 |
| This statement may have some unnecessary parentheses | 160 |
| This statement may have some unnecessary parentheses | 165 |
| Position literals first in String comparisons | 168 |
| This statement may have some unnecessary parentheses | 170 |
| This statement may have some unnecessary parentheses | 179 |
| Deeply nested if..then statements are hard to read | 181–184 |
| Avoid using Literals in Conditional Statements | 181 |
| This statement may have some unnecessary parentheses | 183 |
| This statement may have some unnecessary parentheses | 187 |
| This statement may have some unnecessary parentheses | 199 |
| This statement may have some unnecessary parentheses | 204 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like rt | 61 |
| Avoid variables with short names like p | 66 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 63–74 |
| Violation | Ligne |
|---|---|
| Document empty method | 64–65 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like sr | 66 |
| Avoid variables with short names like sw | 67 |
| These nested if statements could be combined | 77–80 |
| Violation | Ligne |
|---|---|
| Document empty method | 56–57 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 102–120 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 113 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 210 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 239 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 46–50 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 80 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 81 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 82 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 85 |
| Avoid variables with short names like sb | 152 |
| Position literals first in String comparisons | 198 |
| Position literals first in String comparisons | 200 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 241 |
| Prefer StringBuffer over += for concatenating strings | 247 |
| Violation | Ligne |
|---|---|
| Returning '_strImage' may expose an internal array. | 57 |
| The user-supplied array 'strImage' is stored directly. | 65 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 48 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like sc | 96 |
| Avoid variables with short names like in | 105 |
| Avoid using Literals in Conditional Statements | 193 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 52 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–354 |
| Avoid really long methods. | 121–226 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 274 |
| Avoid variables with short names like p | 275 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 284 |
| Avoid variables with short names like fw | 318 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 325 |
| Avoid printStackTrace(); use a logger call instead. | 327 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like e | 54 |
| Violation | Ligne |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 70 |
| Violation | Ligne |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 70 |
| Violation | Ligne |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 70 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like rt | 60 |
| Avoid variables with short names like p | 65 |
| Violation | Ligne |
|---|---|
| Do not add empty strings | 268 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 54 |
| Avoid variables with short names like is | 71 |
| Violation | Ligne |
|---|---|
| Generics names should be a one letter long and upper case. | 51 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 50 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 42–53 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 50–90 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 76 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 87 |
| Avoid variables with short names like ds | 97 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 99 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 110 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 131 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 141 |
| Avoid variables with short names like tm | 143 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 146 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 149 |
| This statement may have some unnecessary parentheses | 169 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 50–55 |
| Use block level rather than method level synchronization | 62–74 |
| Violation | Ligne |
|---|---|
| Avoid appending characters as strings in StringBuffer.append. | 61 |
| Document empty method | 72–73 |
| Document empty method | 80–81 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 47 |
| It is a good practice to call super() in a constructor | 54–56 |
| Singleton is not thread safe | 73–81 |
| Violation | Ligne |
|---|---|
| A getX() method which returns a boolean should be named isX() | 237–240 |
| Violation | Ligne |
|---|---|
| The class 'MailSenderDaemon' has a Modified Cyclomatic Complexity of 10 (Highest = 11). | 56–282 |
| The class 'MailSenderDaemon' has a Cyclomatic Complexity of 12 (Highest = 12). | 56–282 |
| The class 'MailSenderDaemon' has a Standard Cyclomatic Complexity of 12 (Highest = 12). | 56–282 |
| The method 'run' has a Cyclomatic Complexity of 11. | 70–188 |
| Use block level rather than method level synchronization | 70–188 |
| Avoid really long methods. | 70–188 |
| The method 'run' has a Modified Cyclomatic Complexity of 11. | 70–188 |
| The method 'run' has a Standard Cyclomatic Complexity of 11. | 70–188 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 170 |
| The String literal "MailService - Error sending mail : " appears 5 times in this file; the first occurrence is on line 172 | 172 |
| The method 'sendMail' has a Cyclomatic Complexity of 12. | 199–281 |
| Avoid unused method parameters such as 'strHost'. | 199 |
| The method sendMail() has an NPath complexity of 753 | 199–281 |
| The method 'sendMail' has a Standard Cyclomatic Complexity of 12. | 199–281 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 256 |
| Violation | Ligne |
|---|---|
| Rather than using a lot of String arguments, consider using a container object for those values. | 76–77 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 95–96 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 116–117 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 140–141 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 174–175 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 200–202 |
| Avoid long parameter lists. | 229–231 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 229–231 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 263–264 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 285–287 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 310–312 |
| Avoid long parameter lists. | 310–312 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 342–343 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 361–362 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 383–384 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 416–417 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 439–441 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 465–467 |
| Avoid variables with short names like sb | 564 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=52, ATFD=72, TCC=0.1619047619047619) | 34–820 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–820 |
| The class 'MailUtil' has a Cyclomatic Complexity of 4 (Highest = 12). | 82–820 |
| The class 'MailUtil' has a Modified Cyclomatic Complexity of 3 (Highest = 11). | 82–820 |
| The class 'MailUtil' has a Standard Cyclomatic Complexity of 3 (Highest = 11). | 82–820 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 192–204 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 192–194 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 234–249 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 234–236 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 286–348 |
| Avoid long parameter lists. | 286–288 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 286–288 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 382–384 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 382–423 |
| Avoid long parameter lists. | 382–384 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 444–476 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 444–446 |
| Avoid long parameter lists. | 444–446 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 517–526 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 552–589 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 552–553 |
| New exception is thrown in catch block, original stack trace may be lost | 569 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 601–640 |
| Assigning an Object to null is a code smell. Consider refactoring. | 632 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 649–653 |
| Avoid variables with short names like st | 689 |
| Avoid protected methods in a final class that doesnt extend anything other than Object. Change to private or package access. | 708–728 |
| The method 'convertUrlAttachmentDataSourceToByteArrayDataSource' has a Standard Cyclomatic Complexity of 11. | 736–819 |
| The method 'convertUrlAttachmentDataSourceToByteArrayDataSource' has a Modified Cyclomatic Complexity of 11. | 736–819 |
| The method 'convertUrlAttachmentDataSourceToByteArrayDataSource' has a Cyclomatic Complexity of 12. | 736–819 |
| Avoid variables with short names like bo | 746 |
| Avoid variables with short names like o | 752 |
| These nested if statements could be combined | 757–775 |
| Violation | Ligne |
|---|---|
| Private field '_listMails' could be made final; it is only initialized in the declaration or constructor. | 45 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 69 |
| Violation | Ligne |
|---|---|
| These nested if statements could be combined | 189–193 |
| Violation | Ligne |
|---|---|
| Avoid unused constructor parameters such as 'strBackUrl'. | 112 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 131–132 |
| The user-supplied array 'messageArgs' is stored directly. | 131 |
| Violation | Ligne |
|---|---|
| Rather than using a lot of String arguments, consider using a container object for those values. | 201–202 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 219–220 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 269–271 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 405 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 423 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 441 |
| Violation | Ligne |
|---|---|
| Assigning an Object to null is a code smell. Consider refactoring. | 103 |
| Assigning an Object to null is a code smell. Consider refactoring. | 115 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 97 |
| The method buildPageContent() has an NPath complexity of 12500 | 141–172 |
| Violation | Ligne |
|---|---|
| Consider using varargs for methods or constructors which take an array the last parameter. | 218 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 237–238 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 259–260 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 283–285 |
| Violation | Ligne |
|---|---|
| Use explicit scoping instead of the default package private level | 67–77 |
| clone() method should be implemented only if implementing Cloneable interface | 137–141 |
| clone() method should be implemented only if implementing Cloneable interface | 138 |
| clone() method should throw CloneNotSupportedException | 138–141 |
| Avoid throwing raw exception types. | 140 |
| Violation | Ligne |
|---|---|
| Private field '_pageService' could be made final; it is only initialized in the declaration or constructor. | 52 |
| Violation | Ligne |
|---|---|
| Private field '_page' could be made final; it is only initialized in the declaration or constructor. | 51 |
| Private field '_nType' could be made final; it is only initialized in the declaration or constructor. | 52 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like rt | 63 |
| Avoid variables with short names like p | 68 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=112, ATFD=140, TCC=0.025806451612903226) | 34–1164 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–1164 |
| The class 'PageService' has a Standard Cyclomatic Complexity of 3 (Highest = 21). | 98–1164 |
| The class 'PageService' has a Modified Cyclomatic Complexity of 3 (Highest = 21). | 98–1164 |
| The class 'PageService' has a Cyclomatic Complexity of 3 (Highest = 28). | 98–1164 |
| Avoid really long classes. | 98–1164 |
| The method 'getPage' has a Cyclomatic Complexity of 16. | 244–376 |
| The method 'getPage' has a Standard Cyclomatic Complexity of 14. | 244–376 |
| Avoid really long methods. | 244–376 |
| The method 'getPage' has a Modified Cyclomatic Complexity of 14. | 244–376 |
| The method getPage() has an NPath complexity of 962 | 244–376 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 305 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 325 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 338 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 344 |
| New exception is thrown in catch block, original stack trace may be lost | 374 |
| The method 'buildPageContent' has a Cyclomatic Complexity of 11. | 393–486 |
| The method 'getPageContent' has a Standard Cyclomatic Complexity of 12. | 502–569 |
| The method getPageContent() has an NPath complexity of 1200 | 502–569 |
| The method 'getPageContent' has a Modified Cyclomatic Complexity of 12. | 502–569 |
| The method 'getPageContent' has a Cyclomatic Complexity of 12. | 502–569 |
| Prefer StringBuffer over += for concatenating strings | 525 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 551 |
| Avoid variables with short names like t | 566 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 584 |
| The method 'getPortletContent' has a Cyclomatic Complexity of 28. | 608–736 |
| The method 'getPortletContent' has a Standard Cyclomatic Complexity of 21. | 608–736 |
| The method 'getPortletContent' has a Modified Cyclomatic Complexity of 21. | 608–736 |
| The method getPortletContent() has an NPath complexity of 38400 | 608–736 |
| Avoid really long methods. | 608–736 |
| These nested if statements could be combined | 622–625 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 664 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 666 |
| No need to call String.valueOf to append to a string. | 666 |
| This statement may have some unnecessary parentheses | 677 |
| Prefer StringBuffer over += for concatenating strings | 696 |
| This statement may have some unnecessary parentheses | 710 |
| Prefer StringBuffer over += for concatenating strings | 727 |
| This statement may have some unnecessary parentheses | 984 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1021 |
| Avoid unused method parameters such as 'nIdPage'. | 1046 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1048 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 89–103 |
| Avoid variables with short names like p2 | 145 |
| Avoid variables with short names like p1 | 145 |
| Violation | Ligne |
|---|---|
| This class has a bunch of public methods and attributes | 34–1274 |
| Possible God class (WMC=148, ATFD=83, TCC=0.03287890938251804) | 34–1274 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–1274 |
| Too many fields | 83–1274 |
| Avoid really long classes. | 83–1274 |
| The class 'Plugin' has a Cyclomatic Complexity of 2 (Highest = 13). | 83–1274 |
| Abstract classes should be named AbstractXXX | 83–1274 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 137 |
| Use explicit scoping instead of the default package private level | 152–213 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 209 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 231 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 241 |
| Avoid variables with short names like cs | 419 |
| The method getType() has an NPath complexity of 729 | 611–647 |
| The method 'getType' has a Cyclomatic Complexity of 13. | 611–647 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 616 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 621 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 626 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 631 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 636 |
| Avoid variables with short names like o | 1070 |
| An empty method in an abstract class should be abstract instead | 1119–1122 |
| Violation | Ligne |
|---|---|
| Document empty method | 47–48 |
| Violation | Ligne |
|---|---|
| Private field '_plugin' could be made final; it is only initialized in the declaration or constructor. | 47 |
| Private field '_nType' could be made final; it is only initialized in the declaration or constructor. | 48 |
| Violation | Ligne |
|---|---|
| This class has a bunch of public methods and attributes | 34–963 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–963 |
| Possible God class (WMC=89, ATFD=9, TCC=0.007368421052631579) | 34–963 |
| Too many fields | 79–963 |
| Private field '_listCssStyleSheets' could be made final; it is only initialized in the declaration or constructor. | 97 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 97 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 98 |
| Private field '_listJavascriptFiles' could be made final; it is only initialized in the declaration or constructor. | 98 |
| Private field '_listAdminCssStyleSheets' could be made final; it is only initialized in the declaration or constructor. | 99 |
| Private field '_listAdminJavascriptFiles' could be made final; it is only initialized in the declaration or constructor. | 100 |
| Private field '_listFreemarkerMacrosFiles' could be made final; it is only initialized in the declaration or constructor. | 101 |
| Private field '_listRights' could be made final; it is only initialized in the declaration or constructor. | 102 |
| Private field '_listPortletTypes' could be made final; it is only initialized in the declaration or constructor. | 103 |
| Private field '_listDaemons' could be made final; it is only initialized in the declaration or constructor. | 104 |
| Private field '_listApplications' could be made final; it is only initialized in the declaration or constructor. | 105 |
| Private field '_listFilters' could be made final; it is only initialized in the declaration or constructor. | 106 |
| Private field '_listServlets' could be made final; it is only initialized in the declaration or constructor. | 107 |
| Private field '_listListeners' could be made final; it is only initialized in the declaration or constructor. | 108 |
| Private field '_listContentServices' could be made final; it is only initialized in the declaration or constructor. | 109 |
| Private field '_listSearchIndexers' could be made final; it is only initialized in the declaration or constructor. | 110 |
| Private field '_listInsertServices' could be made final; it is only initialized in the declaration or constructor. | 111 |
| Private field '_listRBACResourceTypes' could be made final; it is only initialized in the declaration or constructor. | 112 |
| Private field '_listPageIncludes' could be made final; it is only initialized in the declaration or constructor. | 113 |
| Private field '_listDashboardComponents' could be made final; it is only initialized in the declaration or constructor. | 114 |
| Private field '_listAdminDashboardComponents' could be made final; it is only initialized in the declaration or constructor. | 115 |
| Private field '_mapParams' could be made final; it is only initialized in the declaration or constructor. | 116 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 116 |
| The String literal "Error loading plugin file : " appears 4 times in this file; the first occurrence is on line 150 | 150 |
| Avoid variables with short names like is | 720 |
| Violation | Ligne |
|---|---|
| The class 'PluginService' has a Standard Cyclomatic Complexity of 2 (Highest = 10). | 60–428 |
| The class 'PluginService' has a Cyclomatic Complexity of 2 (Highest = 10). | 60–428 |
| The class 'PluginService' has a Modified Cyclomatic Complexity of 2 (Highest = 10). | 60–428 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 75 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 202 |
| Use block level rather than method level synchronization | 231–234 |
| The method 'loadPluginsStatus' has a Standard Cyclomatic Complexity of 10. | 286–352 |
| The method 'loadPluginsStatus' has a Modified Cyclomatic Complexity of 10. | 286–352 |
| The method 'loadPluginsStatus' has a Cyclomatic Complexity of 10. | 286–352 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 299 |
| Violation | Ligne |
|---|---|
| The class 'PortalMenuService' has a Cyclomatic Complexity of 3 (Highest = 11). | 65–292 |
| It is a good practice to call super() in a constructor | 79–83 |
| Use block level rather than method level synchronization | 89–97 |
| The method 'buildMenuContent' has a Cyclomatic Complexity of 11. | 146–250 |
| Avoid really long methods. | 146–250 |
| Deeply nested if..then statements are hard to read | 181–190 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 243 |
| These nested if statements could be combined | 266–276 |
| Deeply nested if..then statements are hard to read | 270–275 |
| StringBuffer constructor is initialized with size 16, but has at least 19 characters appended. | 279 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=64, ATFD=103, TCC=0.031578947368421054) | 34–729 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–729 |
| The class 'PortalService' has a Cyclomatic Complexity of 2 (Highest = 12). | 84–729 |
| The class 'PortalService' has a Standard Cyclomatic Complexity of 2 (Highest = 11). | 84–729 |
| The class 'PortalService' has a Modified Cyclomatic Complexity of 2 (Highest = 11). | 84–729 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 128 |
| Avoid variables with short names like cs | 173 |
| Avoid variables with short names like cs | 196 |
| The method 'buildPageContent' has a Modified Cyclomatic Complexity of 11. | 289–359 |
| The method 'buildPageContent' has a Standard Cyclomatic Complexity of 11. | 289–359 |
| The method 'buildPageContent' has a Cyclomatic Complexity of 12. | 289–359 |
| The method buildPageContent() has an NPath complexity of 281250 | 289–359 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 409 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 481 |
| Assigning an Object to null is a code smell. Consider refactoring. | 607 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 676 |
| Violation | Ligne |
|---|---|
| Document empty method | 113–114 |
| Document empty method | 130–131 |
| Violation | Ligne |
|---|---|
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 277 |
| New exception is thrown in catch block, original stack trace may be lost | 290 |
| New exception is thrown in catch block, original stack trace may be lost | 294 |
| New exception is thrown in catch block, original stack trace may be lost | 298 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like rt | 64 |
| Avoid variables with short names like p | 69 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 69–77 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 56–64 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 57–59 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 199 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 199 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 56–64 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 45–89 |
| Violation | Ligne |
|---|---|
| Private field '_mapPermissions' could be made final; it is only initialized in the declaration or constructor. | 56 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 52 |
| Avoid variables with short names like rt | 69 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 54 |
| Private field '_bServiceAvailable' could be made final; it is only initialized in the declaration or constructor. | 55 |
| Singleton is not thread safe | 88–91 |
| Use explicit scoping instead of the default package private level | 110–113 |
| Use explicit scoping instead of the default package private level | 120–123 |
| Assigning an Object to null is a code smell. Consider refactoring. | 154 |
| Assigning an Object to null is a code smell. Consider refactoring. | 163 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 73 |
| Singleton is not thread safe | 88–94 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 129 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 56–59 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 52–244 |
| Private field '_listLoaders' could be made final; it is only initialized in the declaration or constructor. | 60 |
| It is a good practice to call super() in a constructor | 65–79 |
| Avoid variables with short names like st | 95 |
| Position literals first in String comparisons | 139 |
| Avoid variables with short names like i | 209 |
| Avoid variables with short names like i | 227 |
| Avoid variables with short names like j | 233 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 54 |
| Singleton is not thread safe | 68–76 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–623 |
| Possible God class (WMC=56, ATFD=81, TCC=0.06315789473684211) | 34–623 |
| The class 'IndexationService' has a Cyclomatic Complexity of 2 (Highest = 10). | 76–623 |
| Avoid unused private fields such as '_nWriterMergeFactor'. | 91 |
| Avoid unused private fields such as '_nWriterMaxFieldLength'. | 92 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 94 |
| StringBuffers can grow quite a lot, and so may become a source of memory leak (if the owning class has a long life time). | 96 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 135 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 146 |
| Use block level rather than method level synchronization | 172–251 |
| Assigning an Object to null is a code smell. Consider refactoring. | 177 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 219 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 277 |
| The method 'processIncrementalIndexing' has a Cyclomatic Complexity of 10. | 294–343 |
| Unnecessary use of fully qualified name 'org.apache.lucene.document.Document' due to existing import 'org.apache.lucene.document.Document' | 315 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 317 |
| Unnecessary use of fully qualified name 'org.apache.lucene.document.Document' due to existing import 'org.apache.lucene.document.Document' | 319 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 334 |
| Avoid unused private methods such as 'processDocument(IndexerAction,Document)'. | 378 |
| Avoid variables with short names like e | 440 |
| Avoid variables with short names like e | 453 |
| Prefer StringBuffer over += for concatenating strings | 456 |
| Avoid variables with short names like e | 466 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–285 |
| The class 'LuceneSearchEngine' has a Cyclomatic Complexity of 15 (Highest = 26). | 77–285 |
| The class 'LuceneSearchEngine' has a Modified Cyclomatic Complexity of 12 (Highest = 20). | 77–285 |
| The class 'LuceneSearchEngine' has a Standard Cyclomatic Complexity of 12 (Highest = 20). | 77–285 |
| The method 'getSearchResults' has a Standard Cyclomatic Complexity of 20. | 94–250 |
| The method 'getSearchResults' has a Cyclomatic Complexity of 26. | 94–250 |
| Avoid really long methods. | 94–250 |
| The method 'getSearchResults' has a Modified Cyclomatic Complexity of 20. | 94–250 |
| The method getSearchResults() has an NPath complexity of 108540 | 94–250 |
| Avoid variables with short names like ir | 191 |
| Avoid variables with short names like si | 235 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 244 |
| Violation | Ligne |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 106 |
| This statement may have some unnecessary parentheses | 178 |
| Avoid really long methods. | 193–298 |
| Avoid variables with short names like ft | 196 |
| New exception is thrown in catch block, original stack trace may be lost | 233 |
| New exception is thrown in catch block, original stack trace may be lost | 237 |
| Avoid variables with short names like sb | 242 |
| Avoid appending characters as strings in StringBuffer.append. | 248 |
| Avoid appending characters as strings in StringBuffer.append. | 253 |
| Avoid appending characters as strings in StringBuffer.append. | 261 |
| Avoid appending characters as strings in StringBuffer.append. | 271 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 48 |
| Singleton is not thread safe | 63–66 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 93 |
| Violation | Ligne |
|---|---|
| Private field '_strMetadata' could be made final; it is only initialized in the declaration or constructor. | 60 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like rt | 60 |
| Avoid variables with short names like p | 65 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 76 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 91 |
| Violation | Ligne |
|---|---|
| Avoid unused private fields such as 'SPRING_CONTEXT_NAME'. | 51 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 52–443 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 140 |
| Private field '_mapUserInfo' could be made final; it is only initialized in the declaration or constructor. | 140 |
| Returning '_roles' may expose an internal array. | 266 |
| Returning '_groups' may expose an internal array. | 293 |
| Avoid variables with short names like j | 325 |
| Avoid variables with short names like j | 359 |
| An empty method in an abstract class should be abstract instead | 439–442 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 45 |
| It is a good practice to call super() in a constructor | 50–53 |
| Singleton is not thread safe | 61–71 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=55, ATFD=32, TCC=0.011494252873563218) | 34–532 |
| Use block level rather than method level synchronization | 85–104 |
| Position literals first in String comparisons for EqualsIgnoreCase | 91 |
| Assigning an Object to null is a code smell. Consider refactoring. | 102 |
| Assigning an Object to null is a code smell. Consider refactoring. | 313 |
| Position literals first in String comparisons | 417 |
| Use explicit scoping instead of the default package private level | 487–490 |
| Violation | Ligne |
|---|---|
| A class which only has private constructors should be final | 53–146 |
| Singleton is not thread safe | 75–78 |
| Violation | Ligne |
|---|---|
| Private field '_strName' could be made final; it is only initialized in the declaration or constructor. | 48 |
| Private field '_servlet' could be made final; it is only initialized in the declaration or constructor. | 49 |
| Private field '_strMapping' could be made final; it is only initialized in the declaration or constructor. | 50 |
| Private field '_plugin' could be made final; it is only initialized in the declaration or constructor. | 51 |
| Private field '_mapInitParameters' could be made final; it is only initialized in the declaration or constructor. | 52 |
| Violation | Ligne |
|---|---|
| Private field '_strName' could be made final; it is only initialized in the declaration or constructor. | 49 |
| Private field '_context' could be made final; it is only initialized in the declaration or constructor. | 50 |
| Private field '_mapInitParameters' could be made final; it is only initialized in the declaration or constructor. | 51 |
| Violation | Ligne |
|---|---|
| Document empty method | 59–60 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 76 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 87 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 111 |
| Violation | Ligne |
|---|---|
| Private field '_mapInitParameters' could be made final; it is only initialized in the declaration or constructor. | 49 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 49 |
| Violation | Ligne |
|---|---|
| Private field '_listServlets' could be made final; it is only initialized in the declaration or constructor. | 54 |
| Avoid variables with short names like s | 82 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 141 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like se | 49 |
| Avoid variables with short names like se | 60 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 79 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 193 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 247 |
| String.indexOf(char) is faster than String.indexOf(String). | 309 |
| These nested if statements could be combined | 346–351 |
| Violation | Ligne |
|---|---|
| Avoid using Literals in Conditional Statements | 59 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 64 |
| Violation | Ligne |
|---|---|
| Singleton is not thread safe | 285–289 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 52 |
| Singleton is not thread safe | 60–68 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like rt | 62 |
| Avoid variables with short names like p | 67 |
| Violation | Ligne |
|---|---|
| Private field '_listRegisteredListeners' could be made final; it is only initialized in the declaration or constructor. | 55 |
| Violation | Ligne |
|---|---|
| The class 'AdminUserFieldService' has a Cyclomatic Complexity of 4 (Highest = 10). | 63–335 |
| The method 'checkUserFields' has a Cyclomatic Complexity of 10. | 87–121 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 167 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 262 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 271 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 283 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 311 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 323 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 60–68 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 65–73 |
| Violation | Ligne |
|---|---|
| Use of modifier volatile is not recommended. | 52 |
| Use of modifier volatile is not recommended. | 53 |
| Use block level rather than method level synchronization | 66–74 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 56–60 |
| Avoid variables with short names like e | 68 |
| It is a good practice to call super() in a constructor | 68–73 |
| Overridable method 'getInitialException' called during object construction | 72 |
| Document empty constructor | 78–80 |
| It is a good practice to call super() in a constructor | 78–80 |
| Avoid variables with short names like e | 106 |
| Avoid variables with short names like cw | 108 |
| Avoid variables with short names like pw | 109 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 122 |
| Avoid appending characters as strings in StringBuffer.append. | 123 |
| Violation | Ligne |
|---|---|
| Class contains more than one logger. | 49–239 |
| The Logger variable declaration does not contain the static and final modifiers | 60 |
| The Logger variable declaration does not contain the static and final modifiers | 61 |
| The Logger variable declaration does not contain the static and final modifiers | 62 |
| Avoid variables with short names like is | 104 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 136 |
| System.err.println is used | 138 |
| Avoid variables with short names like t | 219 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=64, ATFD=42, TCC=0.0380952380952381) | 34–645 |
| The class 'AppPathService' has a Cyclomatic Complexity of 2 (Highest = 12). | 63–645 |
| New exception is thrown in catch block, original stack trace may be lost | 186 |
| The method getBaseUrl() has an NPath complexity of 240 | 208–263 |
| The method 'getBaseUrl' has a Cyclomatic Complexity of 12. | 208–263 |
| Deeply nested if..then statements are hard to read | 229–232 |
| Prefer StringBuffer over += for concatenating strings | 251 |
| Prefer StringBuffer over += for concatenating strings | 254 |
| Prefer StringBuffer over += for concatenating strings | 259 |
| Prefer StringBuffer over += for concatenating strings | 296 |
| Prefer StringBuffer over += for concatenating strings | 321 |
| Prefer StringBuffer over += for concatenating strings | 358 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 228 |
| An empty statement (semicolon) not part of a loop | 238 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like md | 67 |
| Avoid using Literals in Conditional Statements | 116 |
| Avoid appending characters as strings in StringBuffer.append. | 119 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like id | 49 |
| Avoid variables with short names like id | 57 |
| Violation | Ligne |
|---|---|
| Private field '_listRegisteredListeners' could be made final; it is only initialized in the declaration or constructor. | 46 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=67, ATFD=39, TCC=0.0) | 34–637 |
| Use of modifier volatile is not recommended. | 70 |
| Private field '_bServiceAvailable' could be made final; it is only initialized in the declaration or constructor. | 71 |
| Singleton is not thread safe | 106–109 |
| Assigning an Object to null is a code smell. Consider refactoring. | 209 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 214 |
| Assigning an Object to null is a code smell. Consider refactoring. | 235 |
| Assigning an Object to null is a code smell. Consider refactoring. | 310 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 378 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 404 |
| Assigning an Object to null is a code smell. Consider refactoring. | 426 |
| Assigning an Object to null is a code smell. Consider refactoring. | 458 |
| Assigning an Object to null is a code smell. Consider refactoring. | 476 |
| Assigning an Object to null is a code smell. Consider refactoring. | 487 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 529 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 560 |
| Assigning an Object to null is a code smell. Consider refactoring. | 575 |
| These nested if statements could be combined | 593–601 |
| Deeply nested if..then statements are hard to read | 595–598 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 630 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like rt | 65 |
| Avoid variables with short names like p | 70 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 112 |
| Assigning an Object to null is a code smell. Consider refactoring. | 119 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 76–476 |
| The Logger variable declaration does not contain the static and final modifiers | 80 |
| Private field '_listErrors' could be made final; it is only initialized in the declaration or constructor. | 81 |
| Private field '_listInfos' could be made final; it is only initialized in the declaration or constructor. | 82 |
| Private field '_controller' could be made final; it is only initialized in the declaration or constructor. | 83 |
| Avoid variables with short names like m | 104 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 200 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 303 |
| Avoid variables with short names like os | 462 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 51–53 |
| Violation | Ligne |
|---|---|
| The method localize() has an NPath complexity of 625 | 259–267 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 59 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 136 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 146 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 164 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 175 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 192 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=59, ATFD=52, TCC=0.013333333333333334) | 34–744 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–744 |
| Avoid unused imports such as 'javax.servlet.ServletOutputStream' | 77 |
| Avoid unused imports such as 'javax.servlet.ServletOutputStream' | 77 |
| Abstract classes should be named AbstractXXX | 87–744 |
| The Logger variable declaration does not contain the static and final modifiers | 98 |
| Private field '_listErrors' could be made final; it is only initialized in the declaration or constructor. | 99 |
| Private field '_listInfos' could be made final; it is only initialized in the declaration or constructor. | 100 |
| Private field '_controller' could be made final; it is only initialized in the declaration or constructor. | 102 |
| Avoid variables with short names like m | 145 |
| Avoid variables with short names like t | 259 |
| Avoid variables with short names like t | 290 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 304 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 450 |
| Avoid variables with short names like os | 625 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–581 |
| The class 'PortalJspBean' has a Cyclomatic Complexity of 3 (Highest = 16). | 84–581 |
| The method 'getContent' has a Cyclomatic Complexity of 10. | 160–212 |
| These nested if statements could be combined | 186–191 |
| Deeply nested if..then statements are hard to read | 186–191 |
| Avoid empty catch blocks | 195–198 |
| Avoid variables with short names like cs | 202 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 240 |
| Prefer StringBuffer over += for concatenating strings | 351 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 382 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 382 |
| The method sendResource() has an NPath complexity of 675 | 489–580 |
| The method 'sendResource' has a Cyclomatic Complexity of 16. | 489–580 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 542 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 549 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 84 |
| Avoid variables with short names like t | 100 |
| Violation | Ligne |
|---|---|
| The method getPluginList() has an NPath complexity of 375 | 129–167 |
| Assigning an Object to null is a code smell. Consider refactoring. | 133 |
| Avoid variables with short names like c1 | 138 |
| Avoid variables with short names like c2 | 138 |
| Avoid variables with short names like p1 | 140 |
| Avoid variables with short names like p2 | 141 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 68–292 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 220 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 110 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 115 |
| Avoid variables with short names like t | 127 |
| Avoid using Literals in Conditional Statements | 199 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=48, ATFD=107, TCC=0.045454545454545456) | 34–580 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–580 |
| Private field '_bAdminAvatar' could be made final; it is only initialized in the declaration or constructor. | 137 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 147 |
| Assigning an Object to null is a code smell. Consider refactoring. | 169 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 189 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 217 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 243 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 347 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 439 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 531 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 566 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 76 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=64, ATFD=167, TCC=0.05) | 34–784 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–784 |
| The class 'AdminPageJspBean' has a Cyclomatic Complexity of 4 (Highest = 10). | 86–784 |
| Avoid variables with short names like cs | 184 |
| The method 'doModifyPage' has a Cyclomatic Complexity of 10. | 212–287 |
| The method doModifyPage() has an NPath complexity of 216 | 212–287 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 218 |
| Position literals first in String comparisons | 264 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 341 |
| Avoid unused method parameters such as 'strPortletType'. | 434 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 437 |
| Avoid unused private methods such as 'getPageData(HttpServletRequest,Page)'. | 574 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 576 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 579 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 580 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 583 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 584 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 585 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 586 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 587 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 588 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 592 |
| Avoid using Literals in Conditional Statements | 595 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 691 |
| Avoid unused private methods such as 'getNewParentPageId(HttpServletRequest,Page,int)'. | 725 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 727 |
| Violation | Ligne |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 150 |
| Avoid catching NullPointerException; consider removing the cause of the NPE. | 150 |
| The String literal "Error looking for portlet with id " appears 4 times in this file; the first occurrence is on line 152 | 152 |
| The String literal "User " appears 4 times in this file; the first occurrence is on line 162 | 162 |
| The String literal " is not authorized to permission " appears 4 times in this file; the first occurrence is on line 162 | 162 |
| The String literal " on portlet " appears 4 times in this file; the first occurrence is on line 163 | 163 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 209 |
| Avoid catching NullPointerException; consider removing the cause of the NPE. | 209 |
| Consider simply returning the value vs storing it in local variable 'strUrl' | 233 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 256 |
| Avoid catching NullPointerException; consider removing the cause of the NPE. | 256 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 303 |
| Avoid catching NullPointerException; consider removing the cause of the NPE. | 303 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 46–94 |
| These nested if statements could be combined | 72–75 |
| Violation | Ligne |
|---|---|
| Private field '_service' could be made final; it is only initialized in the declaration or constructor. | 95 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 105 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 129 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 262 |
| Violation | Ligne |
|---|---|
| Private field '_service' could be made final; it is only initialized in the declaration or constructor. | 92 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 103 |
| Violation | Ligne |
|---|---|
| The class 'AdminDocumentationJspBean' has a Modified Cyclomatic Complexity of 5 (Highest = 14). | 69–296 |
| The class 'AdminDocumentationJspBean' has a Standard Cyclomatic Complexity of 5 (Highest = 14). | 69–296 |
| The class 'AdminDocumentationJspBean' has a Cyclomatic Complexity of 6 (Highest = 19). | 69–296 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 146 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 158 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 190 |
| The method 'getFeatureGroupsList' has a Cyclomatic Complexity of 19. | 207–295 |
| The method 'getFeatureGroupsList' has a Standard Cyclomatic Complexity of 14. | 207–295 |
| The method getFeatureGroupsList() has an NPath complexity of 255 | 207–295 |
| The method 'getFeatureGroupsList' has a Modified Cyclomatic Complexity of 14. | 207–295 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 284 |
| Violation | Ligne |
|---|---|
| Avoid reassigning parameters such as 'response' | 73 |
| Violation | Ligne |
|---|---|
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 70 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like t | 105 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 118 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 136 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 160 |
| Assigning an Object to null is a code smell. Consider refactoring. | 210 |
| Position literals first in String comparisons | 210 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 275 |
| Avoid variables with short names like t | 279 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 300 |
| Avoid variables with short names like t | 304 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 319 |
| Position literals first in String comparisons | 322 |
| Position literals first in String comparisons | 322 |
| Position literals first in String comparisons | 322 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 349 |
| Position literals first in String comparisons | 352 |
| Position literals first in String comparisons | 352 |
| Position literals first in String comparisons | 352 |
| Violation | Ligne |
|---|---|
| Position literals first in String comparisons | 122 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 171 |
| Position literals first in String comparisons | 175 |
| Violation | Ligne |
|---|---|
| The class 'RightJspBean' has a Modified Cyclomatic Complexity of 5 (Highest = 13). | 74–376 |
| The class 'RightJspBean' has a Standard Cyclomatic Complexity of 5 (Highest = 13). | 74–376 |
| The class 'RightJspBean' has a Cyclomatic Complexity of 6 (Highest = 18). | 74–376 |
| Perhaps '_nDefaultItemsPerPage' could be replaced by a local variable. | 111 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 128 |
| The method getAssignUsers() has an NPath complexity of 4096 | 142–267 |
| Avoid really long methods. | 142–267 |
| The method 'getAssignUsers' has a Cyclomatic Complexity of 18. | 142–267 |
| The method 'getAssignUsers' has a Modified Cyclomatic Complexity of 13. | 142–267 |
| The method 'getAssignUsers' has a Standard Cyclomatic Complexity of 13. | 142–267 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 144 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 144 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 148 |
| Assigning an Object to null is a code smell. Consider refactoring. | 374 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 73 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 81 |
| Violation | Ligne |
|---|---|
| The class 'LinksInclude' has a Cyclomatic Complexity of 7 (Highest = 19). | 57–212 |
| The class 'LinksInclude' has a Standard Cyclomatic Complexity of 6 (Highest = 14). | 57–212 |
| The class 'LinksInclude' has a Modified Cyclomatic Complexity of 6 (Highest = 14). | 57–212 |
| The method fillTemplate() has an NPath complexity of 1236 | 85–156 |
| The method 'fillTemplate' has a Modified Cyclomatic Complexity of 14. | 85–156 |
| The method 'fillTemplate' has a Standard Cyclomatic Complexity of 14. | 85–156 |
| The method 'fillTemplate' has a Cyclomatic Complexity of 19. | 85–156 |
| Deeply nested if..then statements are hard to read | 112–121 |
| Deeply nested if..then statements are hard to read | 125–136 |
| Deeply nested if..then statements are hard to read | 138–149 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 166 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 183 |
| Violation | Ligne |
|---|---|
| The method fillTemplate() has an NPath complexity of 625 | 69–90 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 85 |
| Avoid variables with short names like t | 94 |
| Violation | Ligne |
|---|---|
| Position literals first in String comparisons for EqualsIgnoreCase | 120 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 196 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 56–144 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 123 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 104 |
| Avoid variables with short names like t | 110 |
| Avoid variables with short names like is | 127 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 156 |
| Violation | Ligne |
|---|---|
| Singleton is not thread safe | 103–121 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–487 |
| Perhaps '_nDefaultItemsPerPage' could be replaced by a local variable. | 123 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 134 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 247 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 268 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 396 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 470 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 473 |
| Violation | Ligne |
|---|---|
| No abstract method which means that the keyword is most likely used to prevent instantiation. Use a private or protected constructor instead. | 41–44 |
| Generics names should be a one letter long and upper case. | 41 |
| Violation | Ligne |
|---|---|
| Generics names should be a one letter long and upper case. | 58 |
| Violation | Ligne |
|---|---|
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 79 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 137 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 142 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 144 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 181 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 202 |
| Violation | Ligne |
|---|---|
| The class 'PortletJspBean' has a Standard Cyclomatic Complexity of 2 (Highest = 11). | 66–384 |
| Abstract classes should be named AbstractXXX | 66–384 |
| The class 'PortletJspBean' has a Modified Cyclomatic Complexity of 2 (Highest = 11). | 66–384 |
| The class 'PortletJspBean' has a Cyclomatic Complexity of 2 (Highest = 16). | 66–384 |
| The method 'setPortletCommonData' has a Cyclomatic Complexity of 16. | 187–284 |
| The method 'setPortletCommonData' has a Modified Cyclomatic Complexity of 11. | 187–284 |
| The method setPortletCommonData() has an NPath complexity of 5760 | 187–284 |
| The method 'setPortletCommonData' has a Standard Cyclomatic Complexity of 11. | 187–284 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 189 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 193 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 198 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 199 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 200 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 201 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 202 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 203 |
| Position literals first in String comparisons | 208 |
| Position literals first in String comparisons | 208 |
| Position literals first in String comparisons | 208 |
| Position literals first in String comparisons | 208 |
| Position literals first in String comparisons | 209 |
| These nested if statements could be combined | 217–220 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–1048 |
| The class 'RoleManagementJspBean' has a Cyclomatic Complexity of 4 (Highest = 16). | 82–1048 |
| The class 'RoleManagementJspBean' has a Modified Cyclomatic Complexity of 3 (Highest = 12). | 82–1048 |
| The class 'RoleManagementJspBean' has a Standard Cyclomatic Complexity of 3 (Highest = 12). | 82–1048 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 228 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 321 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 435 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 495 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 578 |
| Avoid appending characters as strings in StringBuffer.append. | 635 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 635 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 636 |
| Avoid appending characters as strings in StringBuffer.append. | 637 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 637 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 638 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 639 |
| Avoid appending characters as strings in StringBuffer.append. | 639 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 640 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 641 |
| Avoid appending characters as strings in StringBuffer.append. | 641 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 642 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 643 |
| Avoid appending characters as strings in StringBuffer.append. | 643 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 644 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 645 |
| Avoid appending characters as strings in StringBuffer.append. | 645 |
| Avoid appending characters as strings in StringBuffer.append. | 650 |
| Avoid appending characters as strings in StringBuffer.append. | 652 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 662 |
| Avoid appending characters as strings in StringBuffer.append. | 662 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 663 |
| Avoid appending characters as strings in StringBuffer.append. | 664 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 664 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 665 |
| Avoid appending characters as strings in StringBuffer.append. | 666 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 666 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 667 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 668 |
| Avoid appending characters as strings in StringBuffer.append. | 668 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 669 |
| Avoid appending characters as strings in StringBuffer.append. | 670 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 670 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 671 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 672 |
| Avoid appending characters as strings in StringBuffer.append. | 672 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 709 |
| The method 'doSelectPermissions' has a Cyclomatic Complexity of 10. | 749–814 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 751 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 752 |
| Avoid really long methods. | 822–939 |
| The method 'getAssignUsers' has a Standard Cyclomatic Complexity of 12. | 822–939 |
| The method getAssignUsers() has an NPath complexity of 1664 | 822–939 |
| The method 'getAssignUsers' has a Cyclomatic Complexity of 16. | 822–939 |
| The method 'getAssignUsers' has a Modified Cyclomatic Complexity of 12. | 822–939 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 824 |
| Assigning an Object to null is a code smell. Consider refactoring. | 1046 |
| Violation | Ligne |
|---|---|
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 77 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 86 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 111–113 |
| Avoid unnecessary constructors - the compiler will generate these for you | 111–113 |
| Document empty constructor | 111–113 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 124 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 143 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 201 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 201 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 227 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–289 |
| The class 'SearchApp' has a Cyclomatic Complexity of 7 (Highest = 16). | 78–289 |
| The class 'SearchApp' has a Modified Cyclomatic Complexity of 6 (Highest = 14). | 78–289 |
| The class 'SearchApp' has a Standard Cyclomatic Complexity of 6 (Highest = 14). | 78–289 |
| The method 'getPage' has a Standard Cyclomatic Complexity of 14. | 129–251 |
| The method 'getPage' has a Cyclomatic Complexity of 16. | 129–251 |
| The method getPage() has an NPath complexity of 33600 | 129–251 |
| Avoid really long methods. | 129–251 |
| The method 'getPage' has a Modified Cyclomatic Complexity of 14. | 129–251 |
| Prefer StringBuffer over += for concatenating strings | 181 |
| Prefer StringBuffer over += for concatenating strings | 181 |
| Prefer StringBuffer over += for concatenating strings | 185 |
| Prefer StringBuffer over += for concatenating strings | 185 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 221 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 114 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 133 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 207 |
| Violation | Ligne |
|---|---|
| Position literals first in String comparisons | 137 |
| Position literals first in String comparisons | 137 |
| Prefer StringBuffer over += for concatenating strings | 144 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 208 |
| Position literals first in String comparisons | 211 |
| Violation | Ligne |
|---|---|
| The class 'PageTemplatesJspBean' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 69–425 |
| The class 'PageTemplatesJspBean' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 69–425 |
| The class 'PageTemplatesJspBean' has a Cyclomatic Complexity of 4 (Highest = 11). | 69–425 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 162 |
| The method 'doModifyPageTemplate' has a Standard Cyclomatic Complexity of 10. | 236–312 |
| The method 'doModifyPageTemplate' has a Cyclomatic Complexity of 11. | 236–312 |
| The method doModifyPageTemplate() has an NPath complexity of 243 | 236–312 |
| The method 'doModifyPageTemplate' has a Modified Cyclomatic Complexity of 10. | 236–312 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 245 |
| Violation | Ligne |
|---|---|
| Perhaps '_nDefaultItemsPerPage' could be replaced by a local variable. | 116 |
| Prefer StringBuffer over += for concatenating strings | 149 |
| Prefer StringBuffer over += for concatenating strings | 154 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 160 |
| Do not add empty strings | 161 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 177 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 193 |
| Prefer StringBuffer over += for concatenating strings | 238 |
| Prefer StringBuffer over += for concatenating strings | 238 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 255 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 273 |
| Prefer StringBuffer over += for concatenating strings | 277 |
| Prefer StringBuffer over += for concatenating strings | 277 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 279 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 317 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 319 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 325 |
| Avoid using a branching statement as the last in a loop. | 336–337 |
| Violation | Ligne |
|---|---|
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 135 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 136 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 188 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 208 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–522 |
| Perhaps '_nDefaultItemsPerPage' could be replaced by a local variable. | 132 |
| Prefer StringBuffer over += for concatenating strings | 144 |
| Prefer StringBuffer over += for concatenating strings | 144 |
| Prefer StringBuffer over += for concatenating strings | 175 |
| Prefer StringBuffer over += for concatenating strings | 180 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 186 |
| Do not add empty strings | 188 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 207 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 252 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 254 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 255 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 258 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 308 |
| This statement may have some unnecessary parentheses | 336 |
| Avoid variables with short names like is | 443 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 446 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like cs | 100 |
| Avoid variables with short names like cs | 138 |
| Avoid variables with short names like cs | 168 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=52, ATFD=84, TCC=0.14102564102564102) | 34–476 |
| The class 'PluginJspBean' has a Cyclomatic Complexity of 4 (Highest = 13). | 65–476 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 147 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 172 |
| These nested if statements could be combined | 202–207 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 229 |
| The method 'filterPluginsList' has a Cyclomatic Complexity of 13. | 275–324 |
| The method filterPluginsList() has an NPath complexity of 245 | 275–324 |
| The method 'verifyCoreCompatibility' has a Cyclomatic Complexity of 10. | 381–427 |
| The method verifyCoreCompatibility() has an NPath complexity of 800 | 381–427 |
| String.indexOf(char) is faster than String.indexOf(String). | 386 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 407 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 421 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 435 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 459 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like t | 67 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like st | 125 |
| Avoid variables with short names like st | 160 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 210 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 210 |
| Avoid variables with short names like f | 224 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 232 |
| Avoid variables with short names like is | 350 |
| StringBuffer constructor is initialized with size 16, but has at least 39 characters appended. | 365 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 369 |
| Violation | Ligne |
|---|---|
| Perhaps '_filterConfig' could be replaced by a local variable. | 61 |
| Avoid using implementation types like 'LinkedList'; use the interface instead | 74 |
| Avoid using implementation types like 'LinkedList'; use the interface instead | 74 |
| Use block level rather than method level synchronization | 144–202 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 146 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 158 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 162 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 211 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 216 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 221 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 233 |
| Private field '_strRemoteAddr' could be made final; it is only initialized in the declaration or constructor. | 249 |
| Private field '_lRequestTime' could be made final; it is only initialized in the declaration or constructor. | 250 |
| Violation | Ligne |
|---|---|
| Assigning an Object to null is a code smell. Consider refactoring. | 93 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 162 |
| Assigning an Object to null is a code smell. Consider refactoring. | 162 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 183 |
| Assigning an Object to null is a code smell. Consider refactoring. | 188 |
| Violation | Ligne |
|---|---|
| Private field '_item' could be made final; it is only initialized in the declaration or constructor. | 55 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 197 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 197 |
| Violation | Ligne |
|---|---|
| Avoid unused imports such as 'fr.paris.lutece.portal.service.util.AppPathService' | 37 |
| Avoid unused imports such as 'fr.paris.lutece.portal.service.util.AppPathService' | 37 |
| Abstract classes should be named AbstractXXX | 60–209 |
| Perhaps '_filterConfig' could be replaced by a local variable. | 68 |
| An empty method in an abstract class should be abstract instead | 189–192 |
| This statement may have some unnecessary parentheses | 204 |
| Violation | Ligne |
|---|---|
| This statement may have some unnecessary parentheses | 80 |
| Avoid unused private methods such as 'getHandler(HttpServletRequest)'. | 126 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–595 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 217 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 257 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 323 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 323 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 406 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 406 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 410 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 475 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 475 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 478 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=228, ATFD=504, TCC=0.21458773784355178) | 34–2486 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–2486 |
| The class 'AdminUserJspBean' has a Modified Cyclomatic Complexity of 4 (Highest = 18). | 118–2486 |
| The class 'AdminUserJspBean' has a Standard Cyclomatic Complexity of 4 (Highest = 18). | 118–2486 |
| The class 'AdminUserJspBean' has a Cyclomatic Complexity of 5 (Highest = 22). | 118–2486 |
| Avoid really long classes. | 118–2486 |
| Private field '_bAdminAvatar' could be made final; it is only initialized in the declaration or constructor. | 351 |
| Perhaps '_nDefaultItemsPerPage' could be replaced by a local variable. | 354 |
| The method 'getManageAdminUsers' has a Cyclomatic Complexity of 10. | 364–464 |
| Avoid really long methods. | 364–464 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 374 |
| Do not add empty strings | 452 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 483 |
| These nested if statements could be combined | 488–493 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 571 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 598 |
| The method 'doCreateAdminUser' has a Cyclomatic Complexity of 18. | 629–774 |
| The method doCreateAdminUser() has an NPath complexity of 19200 | 629–774 |
| The method 'doCreateAdminUser' has a Standard Cyclomatic Complexity of 16. | 629–774 |
| The method 'doCreateAdminUser' has a Modified Cyclomatic Complexity of 16. | 629–774 |
| Avoid really long methods. | 629–774 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 632 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 633 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 634 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 635 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 636 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 637 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 638 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 639 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 692 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 694 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 793 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 793 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 794 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 820 |
| The method 'doModifyAdminUser' has a Cyclomatic Complexity of 22. | 854–1018 |
| Avoid really long methods. | 854–1018 |
| The method 'doModifyAdminUser' has a Standard Cyclomatic Complexity of 18. | 854–1018 |
| The method 'doModifyAdminUser' has a Modified Cyclomatic Complexity of 18. | 854–1018 |
| The method doModifyAdminUser() has an NPath complexity of 125568 | 854–1018 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 858 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 859 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 860 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 861 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 862 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 863 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 864 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 922 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1035 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1074 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1136 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1174 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1175 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1176 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1177 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1271 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1307 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1340 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1381 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1390 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1421 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1430 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1448 |
| The method getModifyAdminUserRights() has an NPath complexity of 600 | 1466–1529 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1472 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1481 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1490 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1518 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1544 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1551 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1602 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1610 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1632 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1639 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1648 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1678 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1706 |
| Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.admin.AccessDeniedException' due to existing import 'fr.paris.lutece.portal.service.admin.AccessDeniedException' | 1741 |
| The String literal "User " appears 6 times in this file; the first occurrence is on line 1 824 | 1824 |
| The String literal " is not authorized to permission " appears 6 times in this file; the first occurrence is on line 1 824 | 1824 |
| Prefer StringBuffer over += for concatenating strings | 1857 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 2091 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 2265 |
| The String literal "core.advanced_parameters." appears 20 times in this file; the first occurrence is on line 2 273 | 2273 |
| Assigning an Object to null is a code smell. Consider refactoring. | 2422 |
| Avoid unused private methods such as 'reinitUserPasswordsAndNotify(HttpServletRequest)'. | 2429 |
| Violation | Ligne |
|---|---|
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 105 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 121 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 129 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 141 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like t | 70 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like t | 74 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 115 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 183 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 204 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 288 |
| Avoid variables with short names like it | 293 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 334 |
| Avoid variables with short names like it | 339 |
| Violation | Ligne |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 115 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 166 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 253 |
| Deeply nested if..then statements are hard to read | 286–289 |
| Deeply nested if..then statements are hard to read | 293–297 |
| Avoid variables with short names like it | 356 |
| Avoid variables with short names like it | 395 |
| Violation | Ligne |
|---|---|
| Private field '_locale' could be made final; it is only initialized in the declaration or constructor. | 58 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–623 |
| The class 'AdminWorkgroupJspBean' has a Cyclomatic Complexity of 5 (Highest = 17). | 79–623 |
| The class 'AdminWorkgroupJspBean' has a Modified Cyclomatic Complexity of 4 (Highest = 13). | 79–623 |
| The class 'AdminWorkgroupJspBean' has a Standard Cyclomatic Complexity of 4 (Highest = 13). | 79–623 |
| Do not add empty strings | 218 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 254 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 314 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 347 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 348 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 371 |
| The method 'getAssignUsers' has a Modified Cyclomatic Complexity of 13. | 393–513 |
| The method getAssignUsers() has an NPath complexity of 3328 | 393–513 |
| Avoid really long methods. | 393–513 |
| The method 'getAssignUsers' has a Cyclomatic Complexity of 17. | 393–513 |
| The method 'getAssignUsers' has a Standard Cyclomatic Complexity of 13. | 393–513 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 395 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 395 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 399 |
| Assigning an Object to null is a code smell. Consider refactoring. | 621 |
| Violation | Ligne |
|---|---|
| Avoid unnecessary constructors - the compiler will generate these for you | 85–87 |
| Document empty constructor | 85–87 |
| Assigning an Object to null is a code smell. Consider refactoring. | 120 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 212 |
| Avoid using Literals in Conditional Statements | 259 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 53–57 |
| Violation | Ligne |
|---|---|
| Private field '_listRoles' could be made final; it is only initialized in the declaration or constructor. | 54 |
| Document empty method | 164–165 |
| Violation | Ligne |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–604 |
| The class 'XslExportJspBean' has a Cyclomatic Complexity of 4 (Highest = 12). | 90–604 |
| Private field '_nDefaultItemsPerPage' could be made final; it is only initialized in the declaration or constructor. | 154 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 249 |
| The method 'getXslExportData' has a Cyclomatic Complexity of 12. | 476–540 |
| Avoid variables with short names like is | 555 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 558 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 54–124 |
| Avoid excessively long variable names like PROPERTY_TITLE_REQUEST_PARAMETERS_CONTAINS_XSS_CHARACTERS | 56 |
| Avoid excessively long variable names like PROPERTY_REQUEST_PARAMETERS_CONTAINS_XSS_CHARACTERS | 57 |
| Perhaps '_filterConfig' could be replaced by a local variable. | 60 |
| An empty method in an abstract class should be abstract instead | 86–89 |
| Violation | Ligne |
|---|---|
| Possible unsafe assignment to a non-final static field in a constructor. | 58 |
| Use of modifier volatile is not recommended. | 59 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 60 |
| Position literals first in String comparisons for EqualsIgnoreCase | 262 |
| Violation | Ligne |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 146 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 182 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 199 |
| Violation | Ligne |
|---|---|
| No need to call String.valueOf to append to a string. | 65 |
| Violation | Ligne |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 82 |
| Avoid throwing raw exception types. | 87 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 112 |
| Avoid variables with short names like sb | 129 |
| Violation | Ligne |
|---|---|
| Returning 'VARIABLES_PREFIX' may expose an internal array. | 73 |
| Violation | Ligne |
|---|---|
| Possible unsafe assignment to a non-final static field in a constructor. | 53 |
| Private field '_interpolator' could be made final; it is only initialized in the declaration or constructor. | 54 |
| Avoid variables with short names like sb | 108 |
| Violation | Ligne |
|---|---|
| Private field '_locale' could be made final; it is only initialized in the declaration or constructor. | 50 |
| Private field '_constraintViolation' could be made final; it is only initialized in the declaration or constructor. | 51 |
| Private field '_config' could be made final; it is only initialized in the declaration or constructor. | 52 |
| Avoid variables with short names like cv | 60 |
| Violation | Ligne |
|---|---|
| Position literals first in String comparisons | 108 |
| Prefer StringBuffer over += for concatenating strings | 114 |
| Avoid unused method parameters such as 'config'. | 144 |
| Violation | Ligne |
|---|---|
| A getX() method which returns a boolean should be named isX() | 128–131 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=69, ATFD=72, TCC=0.05057471264367816) | 34–726 |
| The class 'DataTableManager' has a Cyclomatic Complexity of 2 (Highest = 23). | 71–726 |
| The class 'DataTableManager' has a Standard Cyclomatic Complexity of 2 (Highest = 18). | 71–726 |
| The class 'DataTableManager' has a Modified Cyclomatic Complexity of 2 (Highest = 18). | 71–726 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 176 |
| Avoid really long methods. | 249–384 |
| The method 'filterSortAndPaginate' has a Cyclomatic Complexity of 23. | 249–384 |
| The method 'filterSortAndPaginate' has a Standard Cyclomatic Complexity of 18. | 249–384 |
| The method 'filterSortAndPaginate' has a Modified Cyclomatic Complexity of 18. | 249–384 |
| The method filterSortAndPaginate() has an NPath complexity of 7416 | 249–384 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 321 |
| Assigning an Object to null is a code smell. Consider refactoring. | 485 |
| Assigning an Object to null is a code smell. Consider refactoring. | 486 |
| A getX() method which returns a boolean should be named isX() | 505–508 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 616 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 700 |
| Violation | Ligne |
|---|---|
| Document empty constructor | 48–50 |
| A getX() method which returns a boolean should be named isX() | 85–88 |
| Violation | Ligne |
|---|---|
| Avoid using implementation types like 'ArrayList'; use the interface instead | 54 |
| Avoid using implementation types like 'ArrayList'; use the interface instead | 54 |
| Private field '_listFilter' could be made final; it is only initialized in the declaration or constructor. | 54 |
| Document empty constructor | 59–61 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 76–79 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 78 |
| Use block level rather than method level synchronization | 88–99 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 91 |
| Use block level rather than method level synchronization | 108–114 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 108 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 111 |
| Unnecessary use of fully qualified name 'java.sql.Timestamp' due to existing import 'java.sql.Timestamp' | 123 |
| Use block level rather than method level synchronization | 123–134 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 126 |
| Unnecessary use of fully qualified name 'java.sql.Timestamp' due to existing import 'java.sql.Timestamp' | 130 |
| This statement may have some unnecessary parentheses | 130 |
| Use block level rather than method level synchronization | 143–154 |
| Use block level rather than method level synchronization | 166–177 |
| Unnecessary use of fully qualified name 'java.sql.Timestamp' due to existing import 'java.sql.Timestamp' | 166 |
| Use block level rather than method level synchronization | 189–200 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 189 |
| Use block level rather than method level synchronization | 212–218 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 215 |
| When instantiating a SimpleDateFormat object, specify a Locale | 243 |
| When instantiating a SimpleDateFormat object, specify a Locale | 342 |
| Unnecessary use of fully qualified name 'java.sql.Timestamp' due to existing import 'java.sql.Timestamp' | 376 |
| Avoid variables with short names like df | 413 |
| Avoid variables with short names like df | 423 |
| Violation | Ligne |
|---|---|
| Deeply nested if..then statements are hard to read | 105–108 |
| Violation | Ligne |
|---|---|
| Private field '_strName' could be made final; it is only initialized in the declaration or constructor. | 45 |
| Private field '_strExtension' could be made final; it is only initialized in the declaration or constructor. | 46 |
| Violation | Ligne |
|---|---|
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 79 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 119 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 160 |
| Violation | Ligne |
|---|---|
| Do not add empty strings | 99 |
| Do not add empty strings | 112 |
| Do not add empty strings | 124 |
| Do not add empty strings | 147 |
| Do not add empty strings | 208 |
| An empty method in an abstract class should be abstract instead | 260–263 |
| An empty method in an abstract class should be abstract instead | 269–272 |
| Prefer StringBuffer over += for concatenating strings | 370 |
| Prefer StringBuffer over += for concatenating strings | 370 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 58–82 |
| Violation | Ligne |
|---|---|
| The class 'ItemNavigator' has a Cyclomatic Complexity of 3 (Highest = 11). | 50–193 |
| Private field '_listItems' could be made final; it is only initialized in the declaration or constructor. | 53 |
| Private field '_strParameterName' could be made final; it is only initialized in the declaration or constructor. | 56 |
| The method 'setCurrentItemId' has a Cyclomatic Complexity of 11. | 77–113 |
| Violation | Ligne |
|---|---|
| It is a good practice to call super() in a constructor | 57–81 |
| Violation | Ligne |
|---|---|
| The class 'MultipartUtil' has a Cyclomatic Complexity of 5 (Highest = 11). | 62–187 |
| The class 'MultipartUtil' has a Standard Cyclomatic Complexity of 5 (Highest = 11). | 62–187 |
| The class 'MultipartUtil' has a Modified Cyclomatic Complexity of 5 (Highest = 11). | 62–187 |
| The method 'convert' has a Cyclomatic Complexity of 11. | 91–186 |
| The method 'convert' has a Modified Cyclomatic Complexity of 11. | 91–186 |
| The method 'convert' has a Standard Cyclomatic Complexity of 11. | 91–186 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 117 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 118 |
| Violation | Ligne |
|---|---|
| Class contains more than one logger. | 51–304 |
| Avoid variables with short names like e | 90 |
| Avoid variables with short names like sb | 224 |
| Avoid variables with short names like sb | 247 |
| Avoid variables with short names like sb | 270 |
| Avoid variables with short names like e | 275 |
| Avoid variables with short names like sb | 297 |
| Violation | Ligne |
|---|---|
| Abstract classes should be named AbstractXXX | 58–211 |
| Private field '_entityClass' could be made final; it is only initialized in the declaration or constructor. | 61 |
| Avoid variables with short names like em | 109 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 118 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 141 |
| Avoid variables with short names like em | 143 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 145 |
| Avoid variables with short names like em | 153 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 155 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 157 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 165 |
| Avoid variables with short names like em | 167 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 169 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 177 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 187 |
| Violation | Ligne |
|---|---|
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 127 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 129 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 130 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 131 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 132 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 133 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 134 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 135 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 136 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 137 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 138 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 139 |
| Violation | Ligne |
|---|---|
| Avoid unnecessary constructors - the compiler will generate these for you | 64–66 |
| Document empty constructor | 64–66 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 115 |
| This statement may have some unnecessary parentheses | 144 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 147 |
| Violation | Ligne |
|---|---|
| Private field '_mainPTM' could be made final; it is only initialized in the declaration or constructor. | 50 |
| Violation | Ligne |
|---|---|
| Private field '_strStatus' could be made final; it is only initialized in the declaration or constructor. | 49 |
| Violation | Ligne |
|---|---|
| Private field '_strErrorCode' could be made final; it is only initialized in the declaration or constructor. | 45 |
| Violation | Ligne |
|---|---|
| Private field '_result' could be made final; it is only initialized in the declaration or constructor. | 45 |
| Violation | Ligne |
|---|---|
| All methods are static. Consider using a utility class instead. Alternatively, you could add a private constructor or make the class abstract to silence this warning. | 51–83 |
| Violation | Ligne |
|---|---|
| Rather than using a lot of String arguments, consider using a container object for those values. | 69–70 |
| Consider replacing this Hashtable with the newer java.util.Map | 72 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 107 |
| Consider replacing this Hashtable with the newer java.util.Map | 112 |
| Avoid variables with short names like sc | 135 |
| Violation | Ligne |
|---|---|
| Private field '_type' could be made final; it is only initialized in the declaration or constructor. | 60 |
| New exception is thrown in catch block, original stack trace may be lost | 79 |
| The user-supplied array 'data' is stored directly. | 91 |
| Violation | Ligne |
|---|---|
| The user-supplied array 'data' is stored directly. | 58 |
| Returning '_data' may expose an internal array. | 71 |
| The user-supplied array 'data' is stored directly. | 78 |
| Violation | Ligne |
|---|---|
| The class 'HtmlDocument' has a Cyclomatic Complexity of 4 (Highest = 10). | 62–319 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 101 |
| Private field '_content' could be made final; it is only initialized in the declaration or constructor. | 101 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 102 |
| Private field '_strBaseUrl' could be made final; it is only initialized in the declaration or constructor. | 102 |
| Private field '_useAbsoluteUrl' could be made final; it is only initialized in the declaration or constructor. | 103 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 103 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 132 |
| The method 'getAllUrlsAttachement' has a Cyclomatic Complexity of 10. | 179–231 |
| Deeply nested if..then statements are hard to read | 212–225 |
| Private field '_strTagName' could be made final; it is only initialized in the declaration or constructor. | 259 |
| Private field '_strAttributeName' could be made final; it is only initialized in the declaration or constructor. | 260 |
| Private field '_strTestedAttributeName' could be made final; it is only initialized in the declaration or constructor. | 261 |
| Private field '_strTestedAttributeValue' could be made final; it is only initialized in the declaration or constructor. | 262 |
| Violation | Ligne |
|---|---|
| The class 'BbcodeUtil' has a Cyclomatic Complexity of 10 (Highest = 24). | 55–366 |
| The class 'BbcodeUtil' has a Modified Cyclomatic Complexity of 9 (Highest = 19). | 55–366 |
| The class 'BbcodeUtil' has a Standard Cyclomatic Complexity of 9 (Highest = 19). | 55–366 |
| Avoid really long methods. | 118–265 |
| The method 'processNestedTags' has a Cyclomatic Complexity of 24. | 118–265 |
| The method 'processNestedTags' has a Standard Cyclomatic Complexity of 19. | 118–265 |
| Avoid long parameter lists. | 118–120 |
| The method processNestedTags() has an NPath complexity of 3564 | 118–265 |
| The method 'processNestedTags' has a Modified Cyclomatic Complexity of 19. | 118–265 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 118–120 |
| Prefer StringBuffer over += for concatenating strings | 138 |
| Avoid variables with short names like o2 | 210 |
| Avoid variables with short names like o1 | 210 |
| Avoid variables with short names like s1 | 212 |
| Avoid variables with short names like s2 | 213 |
| Avoid variables with short names like m | 245 |
| Document empty constructor | 289–291 |
| Avoid variables with short names like sb | 356 |
| Violation | Ligne |
|---|---|
| Avoid modifiers which are implied by the context | 41 |
| Violation | Ligne |
|---|---|
| The method makePassword() has an NPath complexity of 4000 | 102–156 |
| Avoid variables with short names like r | 106 |
| Avoid variables with short names like c1 | 124 |
| Avoid variables with short names like c1 | 130 |
| Avoid variables with short names like c1 | 136 |
| Avoid variables with short names like c1 | 142 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 65 |
| Private field '_pools' could be made final; it is only initialized in the declaration or constructor. | 66 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 66 |
| Use block level rather than method level synchronization | 87–96 |
| Avoid variables with short names like is | 104 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 114 |
| Consider replacing this Hashtable with the newer java.util.Map | 134 |
| Consider replacing this Hashtable with the newer java.util.Map | 145 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 160 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 161 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 163 |
| Consider replacing this Hashtable with the newer java.util.Map | 180 |
| Avoid variables with short names like cs | 181 |
| Avoid catching NullPointerException; consider removing the cause of the NPE. | 189 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 189 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 193 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 206 |
| Avoid variables with short names like cs | 241 |
| Use block level rather than method level synchronization | 252–258 |
| Do not add empty strings | 281 |
| Do not add empty strings | 284 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 68 |
| Avoid using implementation types like 'Hashtable'; use the interface instead | 73 |
| Consider replacing this Hashtable with the newer java.util.Map | 73 |
| Avoid using implementation types like 'Hashtable'; use the interface instead | 73 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 100 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 124 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 129 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 146 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 153 |
| Document empty method | 195–196 |
| Violation | Ligne |
|---|---|
| Private field '_strUrl' could be made final; it is only initialized in the declaration or constructor. | 65 |
| Private field '_strUser' could be made final; it is only initialized in the declaration or constructor. | 66 |
| Private field '_strPassword' could be made final; it is only initialized in the declaration or constructor. | 67 |
| Private field '_nMaxConns' could be made final; it is only initialized in the declaration or constructor. | 68 |
| Private field '_nTimeOut' could be made final; it is only initialized in the declaration or constructor. | 69 |
| The Logger variable declaration does not contain the static and final modifiers | 70 |
| Private field '_logger' could be made final; it is only initialized in the declaration or constructor. | 70 |
| Private field '_freeConnections' could be made final; it is only initialized in the declaration or constructor. | 72 |
| Private field '_strCheckValidConnectionSql' could be made final; it is only initialized in the declaration or constructor. | 73 |
| Avoid variables with short names like lf | 104 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 105 |
| Overridable method 'getConnectionCount' called during object construction | 107 |
| Ensure that resources like this Connection object are closed after use | 121 |
| Avoid variables with short names like pc | 121 |
| New exception is thrown in catch block, original stack trace may be lost | 126 |
| Use block level rather than method level synchronization | 160–207 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 174 |
| New exception is thrown in catch block, original stack trace may be lost | 243 |
| New exception is thrown in catch block, original stack trace may be lost | 243 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 265 |
| Use block level rather than method level synchronization | 314–322 |
| Use block level rather than method level synchronization | 327–351 |
| Ensure that resources like this Connection object are closed after use | 329 |
| Avoid prefixing parameters by in, out or inOut. Uses Javadoc to document this behavior. | 436 |
| Document empty method | 450–451 |
| Violation | Ligne |
|---|---|
| Avoid using implementation types like 'Hashtable'; use the interface instead | 73 |
| Consider replacing this Hashtable with the newer java.util.Map | 73 |
| Avoid using implementation types like 'Hashtable'; use the interface instead | 73 |
| Violation | Ligne |
|---|---|
| Private field '_pool' could be made final; it is only initialized in the declaration or constructor. | 60 |
| Private field '_connection' could be made final; it is only initialized in the declaration or constructor. | 61 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 85 |
| Assigning an Object to null is a code smell. Consider refactoring. | 93 |
| Assigning an Object to null is a code smell. Consider refactoring. | 98 |
| Violation | Ligne |
|---|---|
| The class 'LuteceConnectionService' has a Cyclomatic Complexity of 2 (Highest = 10). | 51–235 |
| The class 'LuteceConnectionService' has a Standard Cyclomatic Complexity of 2 (Highest = 10). | 51–235 |
| The class 'LuteceConnectionService' has a Modified Cyclomatic Complexity of 2 (Highest = 10). | 51–235 |
| The Logger variable declaration does not contain the static and final modifiers | 54 |
| Avoid using implementation types like 'Hashtable'; use the interface instead | 97 |
| Avoid using implementation types like 'Hashtable'; use the interface instead | 97 |
| The method init() has an NPath complexity of 15000 | 97–156 |
| Consider replacing this Hashtable with the newer java.util.Map | 97 |
| The method 'init' has a Modified Cyclomatic Complexity of 10. | 97–156 |
| The method 'init' has a Cyclomatic Complexity of 10. | 97–156 |
| The method 'init' has a Standard Cyclomatic Complexity of 10. | 97–156 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 129 |
| Avoid catching NullPointerException; consider removing the cause of the NPE. | 129 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 134 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 56 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 77 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 98 |
| Avoid using implementation types like 'Hashtable'; use the interface instead | 107 |
| Avoid using implementation types like 'Hashtable'; use the interface instead | 107 |
| Consider replacing this Hashtable with the newer java.util.Map | 107 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 116 |
| Violation | Ligne |
|---|---|
| The class 'AttributeComparator' has a Modified Cyclomatic Complexity of 4 (Highest = 12). | 49–207 |
| The class 'AttributeComparator' has a Cyclomatic Complexity of 5 (Highest = 15). | 49–207 |
| The class 'AttributeComparator' has a Standard Cyclomatic Complexity of 4 (Highest = 12). | 49–207 |
| Private field '_strSortedAttribute' could be made final; it is only initialized in the declaration or constructor. | 52 |
| Private field '_bIsASC' could be made final; it is only initialized in the declaration or constructor. | 53 |
| The method 'compare' has a Modified Cyclomatic Complexity of 12. | 83–154 |
| The method 'compare' has a Cyclomatic Complexity of 15. | 83–154 |
| Avoid variables with short names like o2 | 83 |
| The method 'compare' has a Standard Cyclomatic Complexity of 12. | 83–154 |
| Avoid variables with short names like o1 | 83 |
| Position literals first in String comparisons | 119 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 173 |
| Violation | Ligne |
|---|---|
| Possible God class (WMC=110, ATFD=61, TCC=0.0045045045045045045) | 34–1146 |
| The class 'DAOUtil' has a Cyclomatic Complexity of 2 (Highest = 10). | 71–1146 |
| The class 'DAOUtil' has a Modified Cyclomatic Complexity of 2 (Highest = 10). | 71–1146 |
| The class 'DAOUtil' has a Standard Cyclomatic Complexity of 2 (Highest = 10). | 71–1146 |
| Avoid really long classes. | 71–1146 |
| The Logger variable declaration does not contain the static and final modifiers | 98 |
| StringBuffers can grow quite a lot, and so may become a source of memory leak (if the owning class has a long life time). | 99 |
| Private field '_sbLogs' could be made final; it is only initialized in the declaration or constructor. | 99 |
| The constructor 'DAOUtil' has a Cyclomatic Complexity of 10. | 117–197 |
| The constructor 'DAOUtil' has a Modified Cyclomatic Complexity of 10. | 117–197 |
| The constructor 'DAOUtil' has a Standard Cyclomatic Complexity of 10. | 117–197 |
| Avoid variables with short names like ds | 162 |
| Avoid variables with short names like e | 204 |
| StringBuffer constructor is initialized with size 32, but has at least 47 characters appended. | 208 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 209 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 210 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 210 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 211 |
| Assigning an Object to null is a code smell. Consider refactoring. | 308 |
| Avoid variables with short names like ts | 601 |
| Violation | Ligne |
|---|---|
| Avoid variables with short names like e | 144 |
| Violation | Ligne |
|---|---|
| The Logger variable declaration does not contain the static and final modifiers | 87 |
| The String literal "Plugin : '" appears 7 times in this file; the first occurrence is on line 129 | 129 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 153 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 171 |
| Avoid variables with short names like e | 192 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 204 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 208 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 263 |
| Assigning an Object to null is a code smell. Consider refactoring. | 307 |
| Violation | Ligne |
|---|---|
| Avoid using Literals in Conditional Statements | 158 |
| Avoid variables with short names like e | 190 |
| Avoid variables with short names like e | 223 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 227 |
| Violation | Ligne |
|---|---|
| Use block level rather than method level synchronization | 123–132 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 142 |
| Use block level rather than method level synchronization | 142–156 |
| Use block level rather than method level synchronization | 166–175 |
| Use block level rather than method level synchronization | 183–209 |
| Use block level rather than method level synchronization | 218–221 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 230 |
| Use block level rather than method level synchronization | 230–235 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 243 |
| Use block level rather than method level synchronization | 243–275 |
| Use block level rather than method level synchronization | 289–292 |
| Violation | Ligne |
|---|---|
| Private field '_strRoot' could be made final; it is only initialized in the declaration or constructor. | 53 |
| Private field '_listParameters' could be made final; it is only initialized in the declaration or constructor. | 56 |
| Violation | Ligne |
|---|---|
| Private field '_strName' could be made final; it is only initialized in the declaration or constructor. | 46 |
| Private field '_strValue' could be made final; it is only initialized in the declaration or constructor. | 49 |
| Violation | Ligne |
|---|---|
| A method/constructor shouldnt explicitly throw java.lang.Exception | 86 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 86 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 108 |
| Prefer StringBuffer over += for concatenating strings | 116 |
| New exception is thrown in catch block, original stack trace may be lost | 119 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 209 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 209 |
| Avoid variables with short names like sw | 228 |
| Prefer StringBuffer over += for concatenating strings | 241 |
| New exception is thrown in catch block, original stack trace may be lost | 244 |
| Violation | Ligne |
|---|---|
| The class 'XmlUtil' has a Standard Cyclomatic Complexity of 2 (Highest = 10). | 57–342 |
| The class 'XmlUtil' has a Modified Cyclomatic Complexity of 2 (Highest = 10). | 57–342 |
| The class 'XmlUtil' has a Cyclomatic Complexity of 2 (Highest = 10). | 57–342 |
| The method 'transform' has a Modified Cyclomatic Complexity of 10. | 98–159 |
| The method 'transform' has a Cyclomatic Complexity of 10. | 98–159 |
| The method 'transform' has a Standard Cyclomatic Complexity of 10. | 98–159 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 99 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 99 |
| Avoid variables with short names like sw | 123 |
| Prefer StringBuffer over += for concatenating strings | 135 |
| The String literal "Error transforming document XSLT : " appears 4 times in this file; the first occurrence is on line 138 | 138 |
| New exception is thrown in catch block, original stack trace may be lost | 138 |
| Prefer StringBuffer over += for concatenating strings | 150 |
| New exception is thrown in catch block, original stack trace may be lost | 153 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 155 |
| Avoid appending characters as strings in StringBuffer.append. | 172 |
| Avoid appending characters as strings in StringBuffer.append. | 227 |
