The following document contains the results of PMD 5.3.5.
| Violation | Line |
|---|---|
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.impl.dataobjects' | 39 |
| The class 'BaseRepository' has a Standard Cyclomatic Complexity of 3 (Highest = 12). | 50–318 |
| Abstract classes should be named AbstractXXX | 50–318 |
| The class 'BaseRepository' has a Cyclomatic Complexity of 3 (Highest = 14). | 50–318 |
| This abstract class does not have any abstract methods | 50–318 |
| Avoid variables with short names like pd | 60 |
| Avoid variables with short names like pm | 75 |
| Avoid variables with short names like id | 90 |
| Avoid variables with short names like id | 108 |
| Avoid variables with short names like id | 127 |
| Avoid variables with short names like id | 145 |
| Avoid variables with short names like id | 158 |
| Avoid variables with short names like id | 177 |
| Avoid variables with short names like id | 195 |
| Avoid variables with short names like id | 215 |
| The method 'addPropertyDefault' has a Cyclomatic Complexity of 14. | 236–303 |
| The method 'addPropertyDefault' has a Standard Cyclomatic Complexity of 12. | 236–303 |
| Avoid throwing raw exception types. | 296 |
| Violation | Line |
|---|---|
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.data' | 38 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 120–122 |
| Avoid long parameter lists. | 120–122 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 134–136 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 145–147 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 159–161 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 180–182 |
| Violation | Line |
|---|---|
| Private field 'threadLocalService' could be made final; it is only initialized in the declaration or constructor. | 53 |
| Violation | Line |
|---|---|
| Possible God class (WMC=63, ATFD=160, TCC=0.09090909090909091) | 34–762 |
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.data' | 41 |
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.enums' | 45 |
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.exceptions' | 46 |
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.impl.dataobjects' | 47 |
| The class 'DocumentRepository' has a Cyclomatic Complexity of 5 (Highest = 15). | 64–762 |
| The class 'DocumentRepository' has a Standard Cyclomatic Complexity of 5 (Highest = 14). | 64–762 |
| The class 'DocumentRepository' has a Modified Cyclomatic Complexity of 5 (Highest = 14). | 64–762 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 158 |
| The method 'getChildren' has a Cyclomatic Complexity of 15. | 216–325 |
| Avoid really long methods. | 216–325 |
| The method 'getChildren' has a Modified Cyclomatic Complexity of 14. | 216–325 |
| Avoid reassigning parameters such as 'folderId' | 216 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 216–219 |
| The method 'getChildren' has a Standard Cyclomatic Complexity of 14. | 216–325 |
| The method getChildren() has an NPath complexity of 26000 | 216–325 |
| Avoid long parameter lists. | 216–219 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 225 |
| Avoid long parameter lists. | 342–344 |
| Avoid unused method parameters such as 'includeAllowableActions'. | 366 |
| Avoid reassigning parameters such as 'objectId' | 366 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 366–368 |
| Avoid unused method parameters such as 'filter'. | 366 |
| Avoid long parameter lists. | 366–368 |
| Avoid unused method parameters such as 'renditionFilter'. | 367 |
| Avoid unused method parameters such as 'includeRelationships'. | 367 |
| Avoid unused method parameters such as 'includePolicyIds'. | 367 |
| Avoid unused method parameters such as 'extension'. | 368 |
| Avoid unused method parameters such as 'includeAcl'. | 368 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 394 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 397 |
| This call to String.startsWith can be rewritten using String.charAt(0) | 400 |
| The method getDescendants() has an NPath complexity of 1000 | 468–509 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 473 |
| Avoid variables with short names like d | 476 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 503 |
| Avoid unused method parameters such as 'userReadOnly'. | 512 |
| Avoid unused method parameters such as 'includeAcl'. | 512 |
| Avoid unused method parameters such as 'includeAllowableActions'. | 512 |
| Avoid really long methods. | 537–641 |
| Unnecessary use of fully qualified name 'org.apache.chemistry.opencmis.commons.data.Properties' due to existing import 'org.apache.chemistry.opencmis.commons.data.*' | 537 |
| Assigning an Object to null is a code smell. Consider refactoring. | 546 |
| Avoid variables with short names like id | 555 |
| Do not add empty strings | 606 |
| These nested if statements could be combined | 624–627 |
| Avoid empty if statements | 625–627 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 632 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 634 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 656 |
| Position literals first in String comparisons | 667 |
| Avoid long parameter lists. | 686–688 |
| Avoid reassigning parameters such as 'folderPath' | 688 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 702 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 734 |
| Violation | Line |
|---|---|
| Private field '_id' could be made final; it is only initialized in the declaration or constructor. | 53 |
| Violation | Line |
|---|---|
| Possible God class (WMC=61, ATFD=212, TCC=0.045454545454545456) | 34–656 |
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.enums' | 41 |
| Avoid unused imports such as 'org.apache.chemistry.opencmis.commons.impl.dataobjects' | 44 |
| The class 'TypeManager' has a Cyclomatic Complexity of 4 (Highest = 16). | 58–656 |
| The class 'TypeManager' has a Standard Cyclomatic Complexity of 4 (Highest = 14). | 58–656 |
| The class 'TypeManager' has a Modified Cyclomatic Complexity of 4 (Highest = 14). | 58–656 |
| Avoid variables with short names like id | 283 |
| Avoid throwing raw exception types. | 331 |
| Avoid variables with short names like tc | 422 |
| The method 'getTypesChildren' has a Cyclomatic Complexity of 16. | 454–531 |
| The method 'getTypesChildren' has a Modified Cyclomatic Complexity of 14. | 454–531 |
| The method getTypesChildren() has an NPath complexity of 6300 | 454–531 |
| The method 'getTypesChildren' has a Standard Cyclomatic Complexity of 14. | 454–531 |
| Avoid using Literals in Conditional Statements | 468 |
| Avoid using Literals in Conditional Statements | 475 |
| Avoid variables with short names like tc | 492 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 544 |
| Avoid variables with short names like d | 547 |
| Avoid variables with short names like tc | 569 |
| Avoid variables with short names like tc | 583 |
| These nested if statements could be combined | 599–609 |
| Avoid variables with short names like tc | 622 |
| Avoid variables with short names like tc | 640 |
| Violation | Line |
|---|---|
| Use explicit scoping instead of the default package private level | 51–55 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 61 |
| Violation | Line |
|---|---|
| Use explicit scoping instead of the default package private level | 43–47 |
| Violation | Line |
|---|---|
| Abstract classes should be named AbstractXXX | 57–85 |
| Use explicit scoping instead of the default package private level | 60 |
| Use explicit scoping instead of the default package private level | 62 |
| Violation | Line |
|---|---|
| Use explicit scoping instead of the default package private level | 43–47 |
| Violation | Line |
|---|---|
| Assigning an Object to null is a code smell. Consider refactoring. | 45 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 55 |
| Avoid reassigning parameters such as 'request' | 62 |
| Document empty method | 77–78 |
| Violation | Line |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 38 |
| Overridable method 'put' called during object construction | 44 |
| Violation | Line |
|---|---|
| Logger should be defined private static final and have the correct class | 44 |
| Avoid empty catch blocks | 110–112 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 132 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 147 |
| Violation | Line |
|---|---|
| Avoid variables with short names like p | 28 |
| Violation | Line |
|---|---|
| Avoid unnecessary constructors - the compiler will generate these for you | 41–43 |
| Document empty constructor | 41–43 |
| Avoid prefixing parameters by in, out or inOut. Uses Javadoc to document this behavior. | 48 |
| Violation | Line |
|---|---|
| A class which only has private constructors should be final | 45–125 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 84 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 84 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 87 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 88 |
| Avoid variables with short names like u | 94 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 97 |
| Violation | Line |
|---|---|
| Document empty constructor | 42–44 |
| Avoid unnecessary constructors - the compiler will generate these for you | 42–44 |
| Avoid prefixing parameters by in, out or inOut. Uses Javadoc to document this behavior. | 49 |
| Violation | Line |
|---|---|
| Possible God class (WMC=56, ATFD=71, TCC=0.0) | 19–442 |
| Abstract classes should be named AbstractXXX | 44–442 |
| This class has too many methods, consider refactoring it. | 45–442 |
| Avoid variables with short names like id | 128 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 210 |
| Avoid variables with short names like id | 243 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 243 |
| Avoid empty catch blocks | 274–276 |
| Avoid variables with short names like id | 279 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 295 |
| Violation | Line |
|---|---|
| Document empty constructor | 45–47 |
| It is a good practice to call super() in a constructor | 45–47 |
| It is a good practice to call super() in a constructor | 52–55 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 84–85 |
| Violation | Line |
|---|---|
| Possible God class (WMC=110, ATFD=92, TCC=0.14210526315789473) | 19–770 |
| A high number of imports can indicate a high degree of coupling within an object. | 19–770 |
| The class 'AtomEntryParser' has a Cyclomatic Complexity of 5 (Highest = 15). | 65–770 |
| The class 'AtomEntryParser' has a Standard Cyclomatic Complexity of 5 (Highest = 12). | 65–770 |
| The class 'AtomEntryParser' has a Modified Cyclomatic Complexity of 5 (Highest = 12). | 65–770 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 95 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 95 |
| Overridable method 'parse' called during object construction | 98 |
| Assigning an Object to null is a code smell. Consider refactoring. | 123 |
| Assigning an Object to null is a code smell. Consider refactoring. | 160 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 187 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 187 |
| Assigning an Object to null is a code smell. Consider refactoring. | 189 |
| Assigning an Object to null is a code smell. Consider refactoring. | 190 |
| Assigning an Object to null is a code smell. Consider refactoring. | 191 |
| The method 'parseEntry' has a Standard Cyclomatic Complexity of 12. | 236–306 |
| The method 'parseEntry' has a Cyclomatic Complexity of 15. | 236–306 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 236 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 236 |
| The method 'parseEntry' has a Modified Cyclomatic Complexity of 12. | 236–306 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 312 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 312 |
| Avoid variables with short names like u | 314 |
| The method 'parseAtomContent' has a Standard Cyclomatic Complexity of 11. | 326–391 |
| The method 'parseAtomContent' has a Cyclomatic Complexity of 13. | 326–391 |
| The method 'parseAtomContent' has a Modified Cyclomatic Complexity of 11. | 326–391 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 327 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 327 |
| Assigning an Object to null is a code smell. Consider refactoring. | 351 |
| Position literals first in String comparisons | 363 |
| Position literals first in String comparisons | 363 |
| Position literals first in String comparisons | 367 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 397 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 397 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 454 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 454 |
| Avoid variables with short names like sb | 456 |
| Avoid variables with short names like s | 470 |
| Avoid throwing raw exception types. | 479 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 497 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 497 |
| Avoid variables with short names like s | 516 |
| Avoid throwing raw exception types. | 525 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 536 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 551 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 551 |
| The method 'copyStartElement' has a Cyclomatic Complexity of 10. | 610–664 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 611 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 611 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 650 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 654 |
| Avoid reassigning parameters such as 'prefix' | 670 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 671 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 671 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 673 |
| Avoid variables with short names like p | 692 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 707 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 707 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 709 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 725 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 725 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 752 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 752 |
| Violation | Line |
|---|---|
| The class 'AtomFeed' has a Cyclomatic Complexity of 3 (Highest = 13). | 38–189 |
| Document empty constructor | 45–47 |
| It is a good practice to call super() in a constructor | 45–47 |
| It is a good practice to call super() in a constructor | 52–55 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 101–102 |
| Avoid variables with short names like id | 101 |
| Avoid reassigning parameters such as 'maxItems' | 128 |
| The method 'writePagingLinks' has a Cyclomatic Complexity of 13. | 128–188 |
| The method writePagingLinks() has an NPath complexity of 360 | 128–188 |
| Avoid reassigning parameters such as 'skipCount' | 128 |
| Avoid reassigning parameters such as 'maxItems' | 128 |
| Avoid using Literals in Conditional Statements | 149 |
| Avoid using Literals in Conditional Statements | 179 |
| Violation | Line |
|---|---|
| Possible God class (WMC=47, ATFD=107, TCC=0.14285714285714285) | 23–463 |
| The class 'AtomPubUtils' has a Modified Cyclomatic Complexity of 5 (Highest = 24). | 52–463 |
| The class 'AtomPubUtils' has a Cyclomatic Complexity of 5 (Highest = 25). | 52–463 |
| The class 'AtomPubUtils' has a Standard Cyclomatic Complexity of 5 (Highest = 24). | 52–463 |
| Avoid variables with short names like id | 107 |
| Avoid variables with short names like id | 115 |
| The method 'writeObjectEntry' has a Standard Cyclomatic Complexity of 24. | 135–280 |
| The method writeObjectEntry() has an NPath complexity of 2488320 | 135–280 |
| The method 'writeObjectEntry' has a Cyclomatic Complexity of 25. | 135–280 |
| The method 'writeObjectEntry' has a Modified Cyclomatic Complexity of 24. | 135–280 |
| Avoid really long methods. | 135–280 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 273 |
| Avoid empty catch blocks | 303–306 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 303 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 407 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–387 |
| A high number of imports can indicate a high degree of coupling within an object. | 19–387 |
| The class 'CmisAtomPubServlet' has a Standard Cyclomatic Complexity of 7 (Highest = 13). | 87–387 |
| The class 'CmisAtomPubServlet' has a Cyclomatic Complexity of 7 (Highest = 13). | 87–387 |
| The class 'CmisAtomPubServlet' has a Modified Cyclomatic Complexity of 7 (Highest = 13). | 87–387 |
| Assigning an Object to null is a code smell. Consider refactoring. | 104 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 114 |
| Avoid unused local variables such as 'factory'. | 121 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 190 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 192 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 218 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 218 |
| Avoid using Literals in Conditional Statements | 239 |
| The method 'getErrorCode' has a Cyclomatic Complexity of 13. | 274–326 |
| Avoid variables with short names like ex | 274 |
| The method 'getErrorCode' has a Modified Cyclomatic Complexity of 13. | 274–326 |
| The method 'getErrorCode' has a Standard Cyclomatic Complexity of 13. | 274–326 |
| Avoid variables with short names like ex | 331 |
| Avoid variables with short names like pw | 352 |
| Avoid variables with short names like st | 364 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 374 |
| Avoid empty catch blocks | 382–384 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 382 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–313 |
| A class which only has private constructors should be final | 59–313 |
| The class 'DiscoveryService' has a Cyclomatic Complexity of 5 (Highest = 10). | 59–313 |
| The class 'DiscoveryService' has a Standard Cyclomatic Complexity of 5 (Highest = 10). | 59–313 |
| The class 'DiscoveryService' has a Modified Cyclomatic Complexity of 5 (Highest = 10). | 59–313 |
| The method 'query' has a Cyclomatic Complexity of 10. | 71–209 |
| Avoid really long methods. | 71–209 |
| The method 'query' has a Modified Cyclomatic Complexity of 10. | 71–209 |
| The method 'query' has a Standard Cyclomatic Complexity of 10. | 71–209 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 73 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 73 |
| Avoid variables with short names like u | 93 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 96 |
| Assigning an Object to null is a code smell. Consider refactoring. | 130 |
| Avoid variables with short names like id | 211 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 212 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 212 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 243 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 243 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–154 |
| A class which only has private constructors should be final | 43–154 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 54 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 54 |
| Avoid unused method parameters such as 'context'. | 115 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 117 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 117 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–562 |
| A high number of imports can indicate a high degree of coupling within an object. | 19–562 |
| The class 'NavigationService' has a Cyclomatic Complexity of 8 (Highest = 15). | 69–562 |
| The class 'NavigationService' has a Modified Cyclomatic Complexity of 7 (Highest = 14). | 69–562 |
| The class 'NavigationService' has a Standard Cyclomatic Complexity of 7 (Highest = 14). | 69–562 |
| The method 'getChildren' has a Cyclomatic Complexity of 15. | 78–211 |
| Avoid really long methods. | 78–211 |
| The method 'getChildren' has a Standard Cyclomatic Complexity of 14. | 78–211 |
| The method getChildren() has an NPath complexity of 3840 | 78–211 |
| The method 'getChildren' has a Modified Cyclomatic Complexity of 14. | 78–211 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 80 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 80 |
| The String literal "Folder Object Info is missing!" appears 4 times in this file; the first occurrence is on line 108 | 108 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 218 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 218 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 305 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 305 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 393 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 393 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 464 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 464 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–594 |
| Possible God class (WMC=49, ATFD=157, TCC=0.0) | 19–594 |
| A high number of imports can indicate a high degree of coupling within an object. | 19–594 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 81 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 81 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 106 |
| The String literal "Object Info is missing!" appears 5 times in this file; the first occurrence is on line 125 | 125 |
| The String literal "Object is null!" appears 5 times in this file; the first occurrence is on line 132 | 132 |
| The String literal "Location" appears 4 times in this file; the first occurrence is on line 140 | 140 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 154 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 154 |
| Assigning an Object to null is a code smell. Consider refactoring. | 221 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 232 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 232 |
| Avoid empty catch blocks | 251–253 |
| Assigning an Object to null is a code smell. Consider refactoring. | 266 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 282 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 282 |
| Avoid variables with short names like pw | 300 |
| 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 | 381 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 381 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 427 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 427 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 454 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 454 |
| Avoid variables with short names like in | 491 |
| Avoid variables with short names like b | 495 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 511 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 511 |
| Assigning an Object to null is a code smell. Consider refactoring. | 535 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–213 |
| A class which only has private constructors should be final | 45–213 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 120 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 120 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 183 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 183 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–135 |
| A class which only has private constructors should be final | 49–135 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 60 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 60 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 19–458 |
| Too many static imports may lead to messy code | 19–458 |
| The class 'RepositoryService' has a Modified Cyclomatic Complexity of 8 (Highest = 19). | 68–458 |
| The class 'RepositoryService' has a Cyclomatic Complexity of 8 (Highest = 20). | 68–458 |
| The class 'RepositoryService' has a Standard Cyclomatic Complexity of 8 (Highest = 19). | 68–458 |
| The method 'getRepositories' has a Modified Cyclomatic Complexity of 19. | 80–260 |
| Avoid really long methods. | 80–260 |
| The method 'getRepositories' has a Standard Cyclomatic Complexity of 19. | 80–260 |
| The method getRepositories() has an NPath complexity of 37446 | 80–260 |
| The method 'getRepositories' has a Cyclomatic Complexity of 20. | 80–260 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 81 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 81 |
| The method 'getTypeChildren' has a Cyclomatic Complexity of 10. | 265–352 |
| The method getTypeChildren() has an NPath complexity of 5200 | 265–352 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 267 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 267 |
| Assigning an Object to null is a code smell. Consider refactoring. | 279 |
| Assigning an Object to null is a code smell. Consider refactoring. | 280 |
| Assigning an Object to null is a code smell. Consider refactoring. | 291 |
| The method getTypeDescendants() has an NPath complexity of 260 | 357–434 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 359 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 359 |
| Assigning an Object to null is a code smell. Consider refactoring. | 379 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 441 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 441 |
| Violation | Line |
|---|---|
| It is a good practice to call super() in a constructor | 40–42 |
| Avoid unnecessary constructors - the compiler will generate these for you | 40–42 |
| Document empty constructor | 40–42 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–184 |
| A class which only has private constructors should be final | 45–184 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 107 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 107 |
| Violation | Line |
|---|---|
| Abstract classes should be named AbstractXXX | 33–108 |
| This abstract class does not have any abstract methods | 33–108 |
| Avoid prefixing parameters by in, out or inOut. Uses Javadoc to document this behavior. | 65 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–101 |
| 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. | 44–101 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 50 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 50 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 77 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 77 |
| Avoid variables with short names like cp | 84 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 19–637 |
| Possible God class (WMC=82, ATFD=93, TCC=0.0) | 19–637 |
| The class 'BrowserBindingUtils' has a Modified Cyclomatic Complexity of 3 (Highest = 12). | 74–637 |
| A class which only has private constructors should be final | 74–637 |
| The class 'BrowserBindingUtils' has a Standard Cyclomatic Complexity of 4 (Highest = 19). | 74–637 |
| The class 'BrowserBindingUtils' has a Cyclomatic Complexity of 4 (Highest = 19). | 74–637 |
| Avoid using Literals in Conditional Statements | 120 |
| Avoid using Literals in Conditional Statements | 125 |
| Avoid variables with short names like sb | 130 |
| Avoid appending characters as strings in StringBuffer.append. | 139 |
| The method 'createProperties' has a Cyclomatic Complexity of 13. | 229–305 |
| The method createProperties() has an NPath complexity of 308 | 229–305 |
| The method 'createProperties' has a Standard Cyclomatic Complexity of 11. | 229–305 |
| The method 'createProperties' has a Modified Cyclomatic Complexity of 11. | 229–305 |
| Avoid reassigning parameters such as 'typeId' | 229 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 239 |
| Avoid variables with short names like i | 244 |
| Avoid variables with short names like i | 273 |
| The method 'createPropertyData' has a Standard Cyclomatic Complexity of 19. | 308–434 |
| Avoid really long methods. | 308–434 |
| The method 'createPropertyData' has a Cyclomatic Complexity of 19. | 308–434 |
| The method 'createPropertyData' has a Modified Cyclomatic Complexity of 12. | 308–434 |
| Switch statements should have a default label | 328–431 |
| New exception is thrown in catch block, original stack trace may be lost | 353 |
| New exception is thrown in catch block, original stack trace may be lost | 373 |
| New exception is thrown in catch block, original stack trace may be lost | 393 |
| New exception is thrown in catch block, original stack trace may be lost | 415 |
| Avoid variables with short names like i | 452 |
| Avoid variables with short names like i | 475 |
| Avoid reassigning parameters such as 'statusCode' | 515 |
| Avoid variables with short names like ex | 571 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 19–556 |
| Possible God class (WMC=52, ATFD=87, TCC=0.3) | 19–556 |
| Too many static imports may lead to messy code | 19–556 |
| The class 'CmisBrowserBindingServlet' has a Cyclomatic Complexity of 10 (Highest = 21). | 120–556 |
| The class 'CmisBrowserBindingServlet' has a Standard Cyclomatic Complexity of 10 (Highest = 20). | 120–556 |
| The class 'CmisBrowserBindingServlet' has a Modified Cyclomatic Complexity of 10 (Highest = 19). | 120–556 |
| Avoid really long methods. | 132–237 |
| Assigning an Object to null is a code smell. Consider refactoring. | 137 |
| 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 | 256 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 258 |
| The method 'dispatch' has a Standard Cyclomatic Complexity of 20. | 281–434 |
| The method dispatch() has an NPath complexity of 866 | 281–434 |
| The method 'dispatch' has a Cyclomatic Complexity of 21. | 281–434 |
| Avoid really long methods. | 281–434 |
| The method 'dispatch' has a Modified Cyclomatic Complexity of 19. | 281–434 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 282 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 282 |
| Avoid using Literals in Conditional Statements | 303 |
| System.out.println is used | 312 |
| Avoid using Literals in Conditional Statements | 316 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 380 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 396 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 397 |
| The method 'getErrorCode' has a Cyclomatic Complexity of 13. | 439–491 |
| The method 'getErrorCode' has a Standard Cyclomatic Complexity of 13. | 439–491 |
| Avoid variables with short names like ex | 439 |
| The method 'getErrorCode' has a Modified Cyclomatic Complexity of 13. | 439–491 |
| Avoid variables with short names like ex | 496 |
| Assigning an Object to null is a code smell. Consider refactoring. | 516 |
| Avoid variables with short names like st | 527 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 538 |
| Violation | Line |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 37 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 38 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 39 |
| Avoid empty catch blocks | 127–129 |
| Avoid empty catch blocks | 157–159 |
| The String literal "controlName must not be null!" appears 5 times in this file; the first occurrence is on line 193 | 193 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 196 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 206 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 216 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 233 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 243 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–117 |
| A class which only has private constructors should be final | 52–117 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 63 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 63 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 96 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 96 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–125 |
| 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. | 50–125 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 94 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 94 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 19–276 |
| Too many static imports may lead to messy code | 19–276 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 73 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 73 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 109 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 109 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 147 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 147 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 185 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 185 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 211 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 211 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 248 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 248 |
| Violation | Line |
|---|---|
| Possible God class (WMC=52, ATFD=115, TCC=0.0) | 19–692 |
| A high number of imports can indicate a high degree of coupling within an object. | 19–692 |
| Too many static imports may lead to messy code | 19–692 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 108 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 108 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 113 |
| Avoid variables with short names like cp | 116 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 145 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 145 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 148 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 150 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 151 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 154 |
| Avoid variables with short names like cp | 154 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 155 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 191 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 191 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 195 |
| Avoid variables with short names like cp | 198 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 226 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 226 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 230 |
| Avoid variables with short names like cp | 233 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 261 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 261 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 264 |
| Avoid variables with short names like cp | 267 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 295 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 295 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 301 |
| Avoid variables with short names like cp | 304 |
| Assigning an Object to null is a code smell. Consider refactoring. | 307 |
| The String literal "Object is null!" appears 5 times in this file; the first occurrence is on line 318 | 318 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 343 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 343 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 381 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 381 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 427 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 427 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 445 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 445 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 476 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 476 |
| Avoid variables with short names like in | 519 |
| Avoid variables with short names like b | 523 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 539 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 539 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 556 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 556 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 586 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 586 |
| Assigning an Object to null is a code smell. Consider refactoring. | 594 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 620 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 620 |
| Assigning an Object to null is a code smell. Consider refactoring. | 629 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 660 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 660 |
| Violation | Line |
|---|---|
| The class 'POSTHttpServletRequestWrapper' has a Standard Cyclomatic Complexity of 3 (Highest = 13). | 47–277 |
| The class 'POSTHttpServletRequestWrapper' has a Modified Cyclomatic Complexity of 3 (Highest = 13). | 47–277 |
| The class 'POSTHttpServletRequestWrapper' has a Cyclomatic Complexity of 3 (Highest = 15). | 47–277 |
| Perhaps 'isMultipart' could be replaced by a local variable. | 49 |
| Private field 'parameters' could be made final; it is only initialized in the declaration or constructor. | 50 |
| The constructor 'POSTHttpServletRequestWrapper' has a Modified Cyclomatic Complexity of 13. | 56–184 |
| The constructor 'POSTHttpServletRequestWrapper' has a Cyclomatic Complexity of 15. | 56–184 |
| The constructor 'POSTHttpServletRequestWrapper' has a Standard Cyclomatic Complexity of 13. | 56–184 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 57 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 57 |
| The String literal "UTF-8" appears 4 times in this file; the first occurrence is on line 82 | 82 |
| Avoid variables with short names like sb | 86 |
| Avoid variables with short names like b | 89 |
| Avoid empty catch blocks | 104–107 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 104 |
| Avoid variables with short names like os | 116 |
| Avoid variables with short names like b | 121 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 133 |
| Avoid empty catch blocks | 146–149 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 146 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 156 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 163 |
| Avoid variables with short names like sb | 171 |
| Avoid variables with short names like sr | 173 |
| Avoid variables with short names like c | 175 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 186 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 186 |
| Avoid variables with short names like x | 197 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–137 |
| 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. | 47–137 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 53 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 53 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 83 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 83 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 113 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 113 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–84 |
| 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. | 50–84 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 56 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–217 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 65 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 65 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 89 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 89 |
| Avoid variables with short names like ri | 92 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 109 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 109 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 140 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 157 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 157 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 176 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 176 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 205 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 205 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–203 |
| A high number of imports can indicate a high degree of coupling within an object. | 19–203 |
| A class which only has private constructors should be final | 64–203 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 75 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 75 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 79 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 113 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 113 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 130 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 130 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 137 |
| Avoid variables with short names like cp | 140 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 176 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 176 |
| Violation | Line |
|---|---|
| It is a good practice to call super() in a constructor | 47–60 |
| Avoid variables with short names like id | 47 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 81–83 |
| Avoid long parameter lists. | 81–83 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 89–91 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 97–99 |
| Violation | Line |
|---|---|
| Avoid variables with short names like id | 42 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 51 |
| String.trim().length()==0 is an inefficient way to validate an empty String. | 59 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 19–261 |
| This abstract class does not have any abstract methods | 64–261 |
| The class 'AbstractService' has a Cyclomatic Complexity of 6 (Highest = 16). | 64–261 |
| The class 'AbstractService' has a Modified Cyclomatic Complexity of 6 (Highest = 16). | 64–261 |
| The class 'AbstractService' has a Standard Cyclomatic Complexity of 6 (Highest = 16). | 64–261 |
| The method 'createContext' has a Cyclomatic Complexity of 10. | 95–159 |
| Avoid variables with short names like mc | 99 |
| Deeply nested if..then statements are hard to read | 138–150 |
| Avoid using Literals in Conditional Statements | 138 |
| Avoid variables with short names like x | 140 |
| The method 'convertException' has a Cyclomatic Complexity of 16. | 186–260 |
| Avoid variables with short names like ex | 186 |
| The method 'convertException' has a Standard Cyclomatic Complexity of 16. | 186–260 |
| The method 'convertException' has a Modified Cyclomatic Complexity of 16. | 186–260 |
| Violation | Line |
|---|---|
| The class 'AbstractUsernameTokenAuthHandler' has a Cyclomatic Complexity of 10 (Highest = 8). | 51–315 |
| Avoid variables with short names like jc | 57 |
| Avoid printStackTrace(); use a logger call instead. | 65 |
| The String literal "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" appears 5 times in this file; the first occurrence is on line 71 | 71 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 71 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 72 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 73 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 74 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 75 |
| Document empty constructor | 126–128 |
| Avoid unnecessary constructors - the compiler will generate these for you | 126–128 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 179 |
| Avoid variables with short names like id | 212 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 214 |
| Avoid variables with short names like id | 286 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 288 |
| Violation | Line |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 74 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 106 |
| Violation | Line |
|---|---|
| Document empty method | 48–49 |
| Avoid variables with short names like hl | 72 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 79 |
| Avoid empty catch blocks | 79–82 |
| Violation | Line |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 76 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 101 |
| Violation | Line |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 63 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 88 |
| Violation | Line |
|---|---|
| Avoid long parameter lists. | 59–61 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 59–61 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 74 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 84–86 |
| Avoid long parameter lists. | 84–86 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 99 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 109–112 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 136 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 157 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 167–169 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 194 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 204–206 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 231 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–553 |
| A high number of imports can indicate a high degree of coupling within an object. | 19–553 |
| Avoid long parameter lists. | 73–76 |
| Avoid variables with short names like id | 86 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 97 |
| Avoid long parameter lists. | 107–109 |
| Avoid variables with short names like id | 120 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 131 |
| Avoid variables with short names like id | 154 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 164 |
| Avoid variables with short names like id | 187 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 197 |
| Avoid variables with short names like id | 219 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 229 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 258 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 283 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 306 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 327 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 350 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 360–362 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 375 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 385–387 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 400 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 421 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 456 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 483 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 514 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 544 |
| Violation | Line |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 69 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 104 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 129 |
| Violation | Line |
|---|---|
| Avoid long parameter lists. | 50–53 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 50–53 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 65 |
| Violation | Line |
|---|---|
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 86 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 107 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 130 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 151 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 177 |
| Violation | Line |
|---|---|
| Too many static imports may lead to messy code | 19–235 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 79 |
| Avoid long parameter lists. | 89–91 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 109 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 142 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 179 |
| Avoid long parameter lists. | 189–191 |
| Rather than using a lot of String arguments, consider using a container object for those values. | 189–191 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 204 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 226 |
| Violation | Line |
|---|---|
| The class 'WebSphereAuthHandler' has a Cyclomatic Complexity of 4 (Highest = 10). | 37–118 |
| Document empty method | 45–46 |
| The method 'handleMessage' has a Cyclomatic Complexity of 10. | 54–117 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 73 |
| Deeply nested if..then statements are hard to read | 88–91 |
| Avoid empty catch blocks | 93–97 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 93 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 100 |
| Avoid empty catch blocks | 100–103 |
| Violation | Line |
|---|---|
| Avoid unnecessary constructors - the compiler will generate these for you | 43–45 |
| Document empty constructor | 43–45 |
| Avoid variables with short names like x | 55 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 69 |
| Violation | Line |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 53 |
| Private field 'methodMap' could be made final; it is only initialized in the declaration or constructor. | 53 |
| Use block level rather than method level synchronization | 68–75 |
| Avoid variables with short names like m | 71 |
| Avoid variables with short names like m | 87 |
| Avoid variables with short names like s | 127 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 129 |
| Violation | Line |
|---|---|
| A class which only has private constructors should be final | 32–93 |
| Avoid variables with short names like t | 49 |
| Avoid variables with short names like sw | 56 |
| Avoid variables with short names like pw | 57 |
| Avoid variables with short names like t | 67 |
| Avoid variables with short names like st | 71 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 87 |
| Avoid empty catch blocks | 87–89 |
| Violation | Line |
|---|---|
| The class 'HttpUtils' has a Standard Cyclomatic Complexity of 4 (Highest = 16). | 42–310 |
| The class 'HttpUtils' has a Modified Cyclomatic Complexity of 4 (Highest = 16). | 42–310 |
| A class which only has private constructors should be final | 42–310 |
| The class 'HttpUtils' has a Cyclomatic Complexity of 5 (Highest = 17). | 42–310 |
| The method createContext() has an NPath complexity of 928 | 51–164 |
| The method 'createContext' has a Cyclomatic Complexity of 17. | 51–164 |
| Avoid really long methods. | 51–164 |
| The method 'createContext' has a Standard Cyclomatic Complexity of 16. | 51–164 |
| The method 'createContext' has a Modified Cyclomatic Complexity of 16. | 51–164 |
| Avoid variables with short names like eq | 99 |
| Avoid variables with short names like ds | 100 |
| Deeply nested if..then statements are hard to read | 106–109 |
| Deeply nested if..then statements are hard to read | 115–125 |
| This statement may have some unnecessary parentheses | 123 |
| Deeply nested if..then statements are hard to read | 127–130 |
| Deeply nested if..then statements are hard to read | 132–135 |
| Avoid using Literals in Conditional Statements | 148 |
| Avoid variables with short names like x | 150 |
| Avoid variables with short names like p | 171 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 275 |
| New exception is thrown in catch block, original stack trace may be lost | 277 |
| Avoid variables with short names like m | 296 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 300 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 302 |
| New exception is thrown in catch block, original stack trace may be lost | 304 |
| Violation | Line |
|---|---|
| Possible God class (WMC=54, ATFD=8, TCC=0.2692307692307692) | 19–385 |
| Avoid using redundant field initializer for 'buf' | 48 |
| Avoid using redundant field initializer for 'bufSize' | 49 |
| It is a good practice to call super() in a constructor | 59–70 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 179 |
| Avoid empty catch blocks | 179–182 |
| Assigning an Object to null is a code smell. Consider refactoring. | 189 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 195 |
| A method/constructor shouldnt explicitly throw java.lang.Exception | 195 |
| Assigning an Object to null is a code smell. Consider refactoring. | 200 |
| Avoid using redundant field initializer for 'pos' | 233 |
| Avoid variables with short names like b | 264 |
| Avoid variables with short names like b | 270 |
| Avoid reassigning parameters such as 'len' | 270 |
| Avoid reassigning parameters such as 'n' | 289 |
| Avoid variables with short names like n | 289 |
| Assigning an Object to null is a code smell. Consider refactoring. | 309 |
| Avoid using redundant field initializer for 'isDeleted' | 318 |
| Avoid variables with short names like b | 344 |
| Avoid variables with short names like b | 356 |
| Avoid variables with short names like b | 362 |
| Avoid variables with short names like n | 364 |
