The following document contains the results of PMD 6.13.0.
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_objectMapper' doesn't match '[A-Z][A-Z_0-9]*' | 62 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_mapper' doesn't match '[A-Z][A-Z_0-9]*' | 64 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_objectMapper' doesn't match '[A-Z][A-Z_0-9]*' | 61 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name 'CONNECTION_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 57 |
| FieldNamingConventions | The final field name 'CUSTOMER_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 58 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_objectMapper' doesn't match '[A-Z][A-Z_0-9]*' | 61 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strIdentityStoreEndPoint' doesn't match '[a-z][a-zA-Z0-9]*' | 77 |
| FieldNamingConventions | The final field name '_strIdentityPath' doesn't match '[a-z][a-zA-Z0-9]*' | 78 |
| FieldNamingConventions | The final field name '_strTaskStackPath' doesn't match '[a-z][a-zA-Z0-9]*' | 79 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listIdentities' doesn't match '[a-z][a-zA-Z0-9]*' | 83 |
| FieldNamingConventions | The final field name 'CONNECTION_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 84 |
| FieldNamingConventions | The final field name 'CUSTOMER_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 85 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strIdentityStoreEndPoint' doesn't match '[a-z][a-zA-Z0-9]*' | 54 |
| FieldNamingConventions | The final field name '_strIdentityPath' doesn't match '[a-z][a-zA-Z0-9]*' | 55 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 38–60 |
| FieldNamingConventions | The static field name 'instance' doesn't match '_[a-z][a-zA-Z0-9]*' | 40 |
| Rule | Violation | Line |
|---|---|---|
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 132 |
| Rule | Violation | Line |
|---|---|---|
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 100 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 117 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 126 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 135 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 144 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 153 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 65–445 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 127 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 132 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 132 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 136 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 136 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'identityDto' | 143 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 154 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 154 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 157 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 157 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 183 |
| ShortVariable | Avoid variables with short names like in | 217 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'in' | 219 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 230 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 230 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 233 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 233 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 261 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 266 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 266 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 270 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 270 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'responseDto' | 276 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 284 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 284 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 287 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 287 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 322 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 336 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 350 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 365 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 384 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 385 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 406 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 422 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 438 |
| Rule | Violation | Line |
|---|---|---|
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 109 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 109 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 110 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 110 |
| EmptyCatchBlock | Avoid empty catch blocks | 131–133 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 66 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 66 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 74 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 92 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 92 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 104 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 135 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 152 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 152 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 159 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 169 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 200 |
| ShortVariable | Avoid variables with short names like e | 218 |
| Rule | Violation | Line |
|---|---|---|
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 135 |
| Rule | Violation | Line |
|---|---|---|
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 102 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 120 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 213 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 230 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 63–432 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 125 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 129 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 129 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 133 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 133 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'identityDto' | 140 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 153 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 153 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 156 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 156 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 183 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 199 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 199 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 202 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 202 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 233 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 233 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 237 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 237 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'responseDto' | 243 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 252 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 256 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 256 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 260 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 260 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 282 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 282 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 309 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 323 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 337 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 352 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 371 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 372 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 393 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 409 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 425 |
| Rule | Violation | Line |
|---|---|---|
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 108 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 108 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 109 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 109 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 62–65 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 62–65 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 71 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 87 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 98 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 109 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 120 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 165 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 187 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_listIdentities' could be made final; it is only initialized in the declaration or constructor. | 56 |
| FinalFieldCouldBeStatic | This final field could be made static | 57 |
| FinalFieldCouldBeStatic | This final field could be made static | 58 |
| CommentRequired | Public method and constructor comments are required | 60–64 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 60–64 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 63 |
| CyclomaticComplexity | The method 'getIdentity(String, String, String)' has a cyclomatic complexity of 10. | 70–88 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 70 |
| CollapsibleIfStatements | These nested if statements could be combined | 80–83 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 94 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 106 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 117 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 138 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 68 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 68 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 76 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 94 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 94 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 106 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 124 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 124 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 137 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 168 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 185 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 185 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 192 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 202 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 233 |
| ShortVariable | Avoid variables with short names like e | 251 |
| Rule | Violation | Line |
|---|---|---|
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 139 |
| Rule | Violation | Line |
|---|---|---|
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 103 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 121 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 141 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 158 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 176 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 211 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 226 |
| Rule | Violation | Line |
|---|---|---|
| AbstractClassWithoutAbstractMethod | This abstract class does not have any abstract methods | 43–87 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 62–437 |
| CommentRequired | Public method and constructor comments are required | 66–69 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 79 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 89 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 106 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 120 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 137 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 151 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 168 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 182 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 214 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 246 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 258 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 258 |
| UnusedLocalVariable | Avoid unused local variables such as 'mapHeadersResponse'. | 258 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 277 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 283 |
| ShortVariable | Avoid variables with short names like e | 301 |
| MissingOverride | The method 'setApiEndPointUrl(String)' is missing an @Override annotation. | 335–338 |
| MissingOverride | The method 'getApiEndPointUrl()' is missing an @Override annotation. | 345–348 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 369 |
| ShortVariable | Avoid variables with short names like er | 372 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 403 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 421 |
| ShortVariable | Avoid variables with short names like er | 424 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 99 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 99 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 100 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 100 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 108 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 115 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–464 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 75–464 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 117 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 122 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 144 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 165 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 184 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 205 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 226 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 242 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 261 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 280 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 296 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 312 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 328 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 344 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 364 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 378 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 393 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 407 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 421 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 436 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 455 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–337 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 82–337 |
| FinalFieldCouldBeStatic | This final field could be made static | 84 |
| FinalFieldCouldBeStatic | This final field could be made static | 85 |
| CommentRequired | Public method and constructor comments are required | 95–99 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 98 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 105 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 127 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 52–204 |
| UnusedFormalParameter | Avoid unused constructor parameters such as 'httpTransport'. | 80 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 173 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 196 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 50–197 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 90 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 104 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 119 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 134 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 150 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 167 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 172 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 186 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 191 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 38–60 |
| CommentRequired | Public method and constructor comments are required | 42–49 |
| NonThreadSafeSingleton | Singleton is not thread safe | 44–47 |
| ShortVariable | Avoid variables with short names like i | 56 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'setApiEndPointUrl': the method is declared in an interface type | 195 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'getApiEndPointUrl': the method is declared in an interface type | 202 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 69–357 |
| CommentRequired | Public method and constructor comments are required | 352–356 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 44–154 |
| CommentRequired | Public method and constructor comments are required | 149–153 |
| Rule | Violation | Line |
|---|---|---|
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 126 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 148 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 168 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 192 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 214 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 391 |
| PreserveStackTrace | New exception is thrown in catch block, original stack trace may be lost | 393 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.identitystore.web.exception.IdentityNotFoundException' | 47 |
| UnusedImports | Avoid unused imports such as 'org.apache.log4j.Logger' | 54 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'org.apache.log4j.Logger' | 47 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.identitystore.web.exception.IdentityNotFoundException' | 4 | 47 |
| UnusedImports | Avoid unused imports such as 'org.apache.log4j.Logger' | 4 | 54 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 65–445 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 127 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 132 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 132 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 136 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 136 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'identityDto' | 3 | 143 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 154 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 154 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 157 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 157 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 183 |
| ShortVariable | Avoid variables with short names like in | 3 | 217 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'in' | 3 | 219 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 230 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 230 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 233 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 233 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 261 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 266 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 266 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 270 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 270 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'responseDto' | 3 | 276 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 284 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 284 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 287 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 287 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 322 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 336 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 350 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 365 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 384 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 385 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 406 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 422 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 438 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The constant name '_objectMapper' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 62 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 109 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 109 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 110 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 110 |
| EmptyCatchBlock | Avoid empty catch blocks | 3 | 131–133 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 66 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 66 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 74 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 92 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 92 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 104 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 135 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 152 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 152 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 159 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 169 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 200 |
| ShortVariable | Avoid variables with short names like e | 3 | 218 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 135 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 102 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 120 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 213 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 230 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 63–432 |
| FieldNamingConventions | The constant name '_mapper' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 64 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 125 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 129 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 129 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 133 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 133 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'identityDto' | 3 | 140 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 153 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 153 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 156 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 156 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 183 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 199 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 199 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 202 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 202 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 233 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 233 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 237 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 237 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'responseDto' | 3 | 243 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 252 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 256 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 256 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 260 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 260 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 282 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 282 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 309 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 323 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 337 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 352 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 371 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 372 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 393 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 409 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 425 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The constant name '_objectMapper' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 61 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 108 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 108 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 109 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 109 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 2 | 132 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 62–65 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 3 | 62–65 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 71 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 87 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 98 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 109 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 120 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 165 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 187 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_listIdentities' could be made final; it is only initialized in the declaration or constructor. | 3 | 56 |
| FinalFieldCouldBeStatic | This final field could be made static | 3 | 57 |
| FieldNamingConventions | The final field name 'CONNECTION_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 57 |
| FinalFieldCouldBeStatic | This final field could be made static | 3 | 58 |
| FieldNamingConventions | The final field name 'CUSTOMER_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 58 |
| CommentRequired | Public method and constructor comments are required | 3 | 60–64 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 3 | 60–64 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 63 |
| CyclomaticComplexity | The method 'getIdentity(String, String, String)' has a cyclomatic complexity of 10. | 3 | 70–88 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 70 |
| CollapsibleIfStatements | These nested if statements could be combined | 3 | 80–83 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 94 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 106 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 117 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 138 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 68 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 68 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 76 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 94 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 94 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 106 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 124 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 124 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 137 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 168 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 185 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 185 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 192 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 202 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 233 |
| ShortVariable | Avoid variables with short names like e | 3 | 251 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 139 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 103 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 121 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 141 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 158 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 176 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 211 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 226 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AbstractClassWithoutAbstractMethod | This abstract class does not have any abstract methods | 3 | 43–87 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 62–437 |
| CommentRequired | Public method and constructor comments are required | 3 | 66–69 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 79 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 89 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 106 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 120 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 137 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 151 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 168 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 182 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 214 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 246 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 258 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 258 |
| UnusedLocalVariable | Avoid unused local variables such as 'mapHeadersResponse'. | 3 | 258 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 277 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 283 |
| ShortVariable | Avoid variables with short names like e | 3 | 301 |
| MissingOverride | The method 'setApiEndPointUrl(String)' is missing an @Override annotation. | 3 | 335–338 |
| MissingOverride | The method 'getApiEndPointUrl()' is missing an @Override annotation. | 3 | 345–348 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 369 |
| ShortVariable | Avoid variables with short names like er | 3 | 372 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 403 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 421 |
| ShortVariable | Avoid variables with short names like er | 3 | 424 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The constant name '_objectMapper' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 61 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 99 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 99 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 100 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 100 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 108 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 115 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–464 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 75–464 |
| FieldNamingConventions | The final field name '_strIdentityStoreEndPoint' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 77 |
| FieldNamingConventions | The final field name '_strIdentityPath' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 78 |
| FieldNamingConventions | The final field name '_strTaskStackPath' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 79 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 117 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 122 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 144 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 165 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 184 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 205 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 226 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 242 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 261 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 280 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 296 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 312 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 328 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 344 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 364 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 378 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 393 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 407 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 421 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 436 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 455 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–337 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 82–337 |
| FieldNamingConventions | The final field name '_listIdentities' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 83 |
| FinalFieldCouldBeStatic | This final field could be made static | 3 | 84 |
| FieldNamingConventions | The final field name 'CONNECTION_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 84 |
| FinalFieldCouldBeStatic | This final field could be made static | 3 | 85 |
| FieldNamingConventions | The final field name 'CUSTOMER_ID_PREFIX' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 85 |
| CommentRequired | Public method and constructor comments are required | 3 | 95–99 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 98 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 105 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 127 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'org.apache.log4j.Logger' | 4 | 47 |
| CommentRequired | Header comments are required | 3 | 52–204 |
| UnusedFormalParameter | Avoid unused constructor parameters such as 'httpTransport'. | 3 | 80 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 2 | 100 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 2 | 117 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 2 | 126 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 2 | 135 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 2 | 144 |
| GuardLogStatement | Logger calls should be surrounded by log level guards. | 2 | 153 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 173 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 196 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 50–197 |
| FieldNamingConventions | The final field name '_strIdentityStoreEndPoint' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 54 |
| FieldNamingConventions | The final field name '_strIdentityPath' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 55 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 90 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 104 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 119 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 134 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 150 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 167 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 172 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 186 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 191 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 38–60 |
| CommentRequired | Header comments are required | 3 | 38–60 |
| FieldNamingConventions | The static field name 'instance' doesn't match '_[a-z][a-zA-Z0-9]*' | 1 | 40 |
| CommentRequired | Public method and constructor comments are required | 3 | 42–49 |
| NonThreadSafeSingleton | Singleton is not thread safe | 3 | 44–47 |
| ShortVariable | Avoid variables with short names like i | 3 | 56 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'setApiEndPointUrl': the method is declared in an interface type | 3 | 195 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'getApiEndPointUrl': the method is declared in an interface type | 3 | 202 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 69–357 |
| CommentRequired | Public method and constructor comments are required | 3 | 352–356 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 44–154 |
| CommentRequired | Public method and constructor comments are required | 3 | 149–153 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 126 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 148 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 168 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 192 |
| AvoidUncheckedExceptionsInSignatures | A method or constructor should not explicitly declare unchecked exceptions in its 'throws' clause | 3 | 214 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 391 |
| PreserveStackTrace | New exception is thrown in catch block, original stack trace may be lost | 3 | 393 |
