PMD Results
The following document contains the results of PMD 5.3.2.
Files
rdfpro-core - eu/fbk/rdfpro/AbstractRDFHandler.java
| Violation | Line |
|---|---|
| Document empty constructor | 34–35 |
| Document empty method body | 41–42 |
| Document empty method body | 48–49 |
| Document empty method body | 55–56 |
| Document empty method body | 62–63 |
| Document empty method body | 69–70 |
| Document empty method body | 76–77 |
rdfpro-core - eu/fbk/rdfpro/Mapper.java
| Violation | Line |
|---|---|
| Possible God class (WMC=57, ATFD=32, TCC=0.0) | 14–344 |
| Avoid modifiers which are implied by the context | 89–107 |
| Avoid modifiers which are implied by the context | 119–136 |
| Avoid modifiers which are implied by the context | 147–164 |
| Avoid modifiers which are implied by the context | 179–322 |
| Avoid really long methods. | 179–322 |
| The method select() has an NPath complexity of 25879932 | 179–322 |
| Position literals first in String comparisons | 183 |
| The method map() has an NPath complexity of 256 | 242–286 |
| Avoid reassigning parameters such as 'index' | 306 |
| Avoid reassigning parameters such as 'index' | 306 |
| Avoid reassigning parameters such as 'index' | 306 |
| Avoid reassigning parameters such as 'index' | 306 |
rdfpro-core - eu/fbk/rdfpro/ProcessorMapReduce.java
| Violation | Line |
|---|---|
| The class 'Handler' has a Standard Cyclomatic Complexity of 6 (Highest = 12). | 64–259 |
| The class 'Handler' has a Modified Cyclomatic Complexity of 6 (Highest = 12). | 64–259 |
| The class 'Handler' has a Cyclomatic Complexity of 6 (Highest = 14). | 64–259 |
| The method 'handleStatement' has a Modified Cyclomatic Complexity of 12. | 119–148 |
| The method 'handleStatement' has a Standard Cyclomatic Complexity of 12. | 119–148 |
| The method handleStatement() has an NPath complexity of 781252 | 119–148 |
| The method 'handleStatement' has a Cyclomatic Complexity of 12. | 119–148 |
| Avoid instantiating new objects inside loops | 133 |
| Avoid instantiating new objects inside loops | 139–140 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 168 |
| The method accept() has an NPath complexity of 9375 | 168–193 |
| Ensure that resources like this Statement object are closed after use | 179 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 179–180 |
| The method 'flush' has a Standard Cyclomatic Complexity of 12. | 195–257 |
| The method 'flush' has a Cyclomatic Complexity of 14. | 195–257 |
| The method 'flush' has a Modified Cyclomatic Complexity of 12. | 195–257 |
| The method flush() has an NPath complexity of 240 | 195–257 |
| Ensure that resources like this Statement object are closed after use | 222 |
rdfpro-core - eu/fbk/rdfpro/ProcessorRDFS.java
| Violation | Line |
|---|---|
| Possible God class (WMC=274, ATFD=459, TCC=0.0) | 14–1345 |
| The class 'ProcessorRDFS' has a Standard Cyclomatic Complexity of 6 (Highest = 10). | 50–1345 |
| The class 'ProcessorRDFS' has a Cyclomatic Complexity of 6 (Highest = 10). | 50–1345 |
| The class 'ProcessorRDFS' has a Modified Cyclomatic Complexity of 6 (Highest = 10). | 50–1345 |
| The constructor 'ProcessorRDFS' has a Standard Cyclomatic Complexity of 10. | 97–149 |
| The constructor 'ProcessorRDFS' has a Modified Cyclomatic Complexity of 10. | 97–149 |
| The constructor 'ProcessorRDFS' has a Cyclomatic Complexity of 10. | 97–149 |
| Avoid reassigning parameters such as 'value' | 119 |
| Deeply nested if..then statements are hard to read | 129–131 |
| Private field 'inferencer' could be made final; it is only initialized in the declaration or constructor. | 160 |
| Ensure that resources like this Statement object are closed after use | 187 |
| The class 'TBox' has a Standard Cyclomatic Complexity of 17 (Highest = 16). | 196–347 |
| The class 'TBox' has a Modified Cyclomatic Complexity of 17 (Highest = 16). | 196–347 |
| The class 'TBox' has a Cyclomatic Complexity of 24 (Highest = 23). | 196–347 |
| The constructor 'TBox' has a Standard Cyclomatic Complexity of 16. | 208–299 |
| The constructor 'TBox' has a Modified Cyclomatic Complexity of 16. | 208–299 |
| The constructor 'TBox' has a Cyclomatic Complexity of 23. | 208–299 |
| Ensure that resources like this Statement object are closed after use | 216 |
| Ensure that resources like this Statement object are closed after use | 219 |
| Ensure that resources like this Statement object are closed after use | 254 |
| Avoid instantiating new objects inside loops | 261 |
| Avoid instantiating new objects inside loops | 263 |
| Ensure that resources like this Statement object are closed after use | 274 |
| Avoid instantiating new objects inside loops | 280 |
| The user-supplied array 'parents' is stored directly. | 305 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 305 |
| The user-supplied array 'domain' is stored directly. | 319 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 319 |
| The user-supplied array 'range' is stored directly. | 319 |
| The user-supplied array 'parents' is stored directly. | 319 |
| The class 'TBoxInferencer' has a Modified Cyclomatic Complexity of 15 (Highest = 47). | 349–761 |
| The class 'TBoxInferencer' has a Standard Cyclomatic Complexity of 15 (Highest = 47). | 349–761 |
| The class 'TBoxInferencer' has a Cyclomatic Complexity of 19 (Highest = 58). | 349–761 |
| The method decomposeOWLAxioms() has an NPath complexity of 42966 | 430–573 |
| The method 'decomposeOWLAxioms' has a Standard Cyclomatic Complexity of 44. | 430–573 |
| The method 'decomposeOWLAxioms' has a Modified Cyclomatic Complexity of 44. | 430–573 |
| The method decomposeOWLAxioms() has an NCSS line count of 105 | 430–573 |
| Avoid really long methods. | 430–573 |
| The method 'decomposeOWLAxioms' has a Cyclomatic Complexity of 56. | 430–573 |
| Ensure that resources like this Statement object are closed after use | 441 |
| Avoid instantiating new objects inside loops | 463 |
| Avoid instantiating new objects inside loops | 468 |
| Avoid instantiating new objects inside loops | 485 |
| Avoid instantiating new objects inside loops | 493 |
| These nested if statements could be combined | 507–514 |
| Avoid instantiating new objects inside loops | 510 |
| Avoid instantiating new objects inside loops | 523 |
| Avoid instantiating new objects inside loops | 528 |
| The method 'evalRules' has a Standard Cyclomatic Complexity of 47. | 575–735 |
| Avoid really long methods. | 575–735 |
| The method evalRules() has an NPath complexity of 1692057601 | 575–735 |
| The method 'evalRules' has a Modified Cyclomatic Complexity of 47. | 575–735 |
| The method 'evalRules' has a Cyclomatic Complexity of 58. | 575–735 |
| Ensure that resources like this Statement object are closed after use | 585 |
| These nested if statements could be combined | 637–639 |
| Ensure that resources like this Statement object are closed after use | 646 |
| Ensure that resources like this Statement object are closed after use | 650 |
| Ensure that resources like this Statement object are closed after use | 660 |
| Ensure that resources like this Statement object are closed after use | 667 |
| Ensure that resources like this Statement object are closed after use | 692 |
| Ensure that resources like this Statement object are closed after use | 698 |
| Ensure that resources like this Statement object are closed after use | 722 |
| Ensure that resources like this Statement object are closed after use | 728 |
| Ensure that resources like this Statement object are closed after use | 744 |
| The class 'ABoxInferencer' has a Modified Cyclomatic Complexity of 10 (Highest = 27). | 763–971 |
| The class 'ABoxInferencer' has a Standard Cyclomatic Complexity of 10 (Highest = 27). | 763–971 |
| The class 'ABoxInferencer' has a Cyclomatic Complexity of 12 (Highest = 32). | 763–971 |
| The method 'handleStatement' has a Modified Cyclomatic Complexity of 11. | 799–842 |
| The method 'handleStatement' has a Cyclomatic Complexity of 11. | 799–842 |
| The method 'handleStatement' has a Standard Cyclomatic Complexity of 11. | 799–842 |
| The method handleStatement() has an NPath complexity of 1440 | 799–842 |
| Ensure that resources like this Statement object are closed after use | 830 |
| Ensure that resources like this Statement object are closed after use | 835 |
| The method 'infer' has a Cyclomatic Complexity of 32. | 844–916 |
| The method 'infer' has a Standard Cyclomatic Complexity of 27. | 844–916 |
| The method 'infer' has a Modified Cyclomatic Complexity of 27. | 844–916 |
| The method infer() has an NPath complexity of 86400 | 844–916 |
| These nested if statements could be combined | 902–904 |
| The method 'emit' has a Cyclomatic Complexity of 12. | 918–963 |
| Ensure that resources like this Statement object are closed after use | 938 |
| Ensure that resources like this Statement object are closed after use | 953 |
| Avoid instantiating new objects inside loops | 990 |
| These nested if statements could be combined | 1001–1003 |
| Ensure that resources like this Statement object are closed after use | 1010 |
| The class 'Database' has a Modified Cyclomatic Complexity of 5 (Highest = 20). | 1085–1343 |
| The class 'Database' has a Standard Cyclomatic Complexity of 5 (Highest = 20). | 1085–1343 |
| The class 'Database' has a Cyclomatic Complexity of 6 (Highest = 26). | 1085–1343 |
| Avoid really long methods. | 1128–1233 |
| The method filter() has an NPath complexity of 9250 | 1128–1233 |
| The method 'filter' has a Cyclomatic Complexity of 26. | 1128–1233 |
| The method 'filter' has a Standard Cyclomatic Complexity of 20. | 1128–1233 |
| The method 'filter' has a Modified Cyclomatic Complexity of 20. | 1128–1233 |
| The method 'iterator' has a Cyclomatic Complexity of 15. | 1185–1230 |
| Non-static initializers are confusing | 1190–1192 |
| Avoid reassigning parameters such as 'skipCurrent' | 1211 |
| The method 'advance' has a Cyclomatic Complexity of 11. | 1211–1227 |
rdfpro-core - eu/fbk/rdfpro/ProcessorRules.java
| Violation | Line |
|---|---|
| The class 'ProcessorRules' has a Modified Cyclomatic Complexity of 11 (Highest = 27). | 43–295 |
| The class 'ProcessorRules' has a Cyclomatic Complexity of 12 (Highest = 27). | 43–295 |
| The class 'ProcessorRules' has a Standard Cyclomatic Complexity of 11 (Highest = 27). | 43–295 |
| The method 'create' has a Cyclomatic Complexity of 27. | 59–177 |
| The method create() has an NPath complexity of 77395500 | 59–177 |
| The method 'create' has a Modified Cyclomatic Complexity of 27. | 59–177 |
| The method 'create' has a Standard Cyclomatic Complexity of 27. | 59–177 |
| Avoid really long methods. | 59–177 |
| Prefer StringBuffer over += for concatenating strings | 68 |
| Prefer StringBuffer over += for concatenating strings | 88 |
| Prefer StringBuffer over += for concatenating strings | 88 |
| Avoid instantiating new objects inside loops | 111 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 149 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 192 |
| Ensure that resources like this Statement object are closed after use | 212 |
| Ensure that resources like this Statement object are closed after use | 278 |
rdfpro-core - eu/fbk/rdfpro/ProcessorSmush.java
| Violation | Line |
|---|---|
| Possible God class (WMC=83, ATFD=23, TCC=0.0036231884057971015) | 14–447 |
| The class 'Handler' has a Cyclomatic Complexity of 4 (Highest = 13). | 60–446 |
| The method 'handleStatement' has a Cyclomatic Complexity of 13. | 114–147 |
| The method handleStatement() has an NPath complexity of 228 | 114–147 |
| Avoid instantiating new objects inside loops | 192 |
| The method 'matchResource' has a Cyclomatic Complexity of 12. | 381–413 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 383 |
rdfpro-core - eu/fbk/rdfpro/ProcessorStats.java
| Violation | Line |
|---|---|
| Possible God class (WMC=231, ATFD=318, TCC=0.003076923076923077) | 14–1335 |
| Too many fields | 87–736 |
| The class 'Handler' has a Cyclomatic Complexity of 14 (Highest = 38). | 87–736 |
| The class 'Handler' has a Standard Cyclomatic Complexity of 13 (Highest = 36). | 87–736 |
| The class 'Handler' has a Modified Cyclomatic Complexity of 13 (Highest = 36). | 87–736 |
| Local variable 'ps' could be declared final | 148 |
| Avoid really long methods. | 181–296 |
| The method 'handleStatement' has a Standard Cyclomatic Complexity of 22. | 181–296 |
| The method 'handleStatement' has a Modified Cyclomatic Complexity of 22. | 181–296 |
| The method handleStatement() has an NPath complexity of 22680000 | 181–296 |
| The method 'handleStatement' has a Cyclomatic Complexity of 27. | 181–296 |
| The method 'endRDF' has a Modified Cyclomatic Complexity of 13. | 299–372 |
| The method 'endRDF' has a Standard Cyclomatic Complexity of 13. | 299–372 |
| The method 'endRDF' has a Cyclomatic Complexity of 13. | 299–372 |
| Avoid instantiating new objects inside loops | 320 |
| Avoid instantiating new objects inside loops | 329 |
| Avoid instantiating new objects inside loops | 330 |
| Avoid instantiating new objects inside loops | 338 |
| Avoid instantiating new objects inside loops | 339 |
| The method 'handleDirectRecord' has a Cyclomatic Complexity of 23. | 380–441 |
| The method 'handleDirectRecord' has a Modified Cyclomatic Complexity of 19. | 380–441 |
| The method 'handleDirectRecord' has a Standard Cyclomatic Complexity of 19. | 380–441 |
| The method handleDirectRecord() has an NPath complexity of 66924 | 380–441 |
| Avoid instantiating new objects inside loops | 391 |
| Avoid instantiating new objects inside loops | 402 |
| Avoid instantiating new objects inside loops | 404 |
| The method 'handleDirectRecordHelper' has a Modified Cyclomatic Complexity of 18. | 443–516 |
| The method 'handleDirectRecordHelper' has a Cyclomatic Complexity of 18. | 443–516 |
| The method 'handleDirectRecordHelper' has a Standard Cyclomatic Complexity of 18. | 443–516 |
| The method handleDirectRecordHelper() has an NPath complexity of 467460 | 443–516 |
| Avoid instantiating new objects inside loops | 535 |
| The method 'emitStatistics' has a Standard Cyclomatic Complexity of 36. | 545–681 |
| Avoid really long methods. | 545–681 |
| The method 'emitStatistics' has a Cyclomatic Complexity of 38. | 545–681 |
| The method emitStatistics() has an NCSS line count of 108 | 545–681 |
| The method 'emitStatistics' has a Modified Cyclomatic Complexity of 36. | 545–681 |
| The method 'emit' has a Cyclomatic Complexity of 13. | 683–707 |
| Avoid appending characters as strings in StringBuffer.append. | 720 |
| Use block level rather than method level synchronization | 863–869 |
| Use block level rather than method level synchronization | 871–889 |
| The class 'Sampler' has a Cyclomatic Complexity of 8 (Highest = 19). | 934–1016 |
| The method 'add' has a Cyclomatic Complexity of 19. | 958–995 |
| Use block level rather than method level synchronization | 958–995 |
| Ensure that resources like this Statement object are closed after use | 975 |
| Use block level rather than method level synchronization | 997–1014 |
| Ensure that resources like this Statement object are closed after use | 999 |
| Avoid appending characters as strings in StringBuffer.append. | 1004 |
| Avoid appending characters as strings in StringBuffer.append. | 1007 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1082 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1085 |
| The class 'Hash' has a Modified Cyclomatic Complexity of 3 (Highest = 16). | 1145–1300 |
| The class 'Hash' has a Cyclomatic Complexity of 3 (Highest = 17). | 1145–1300 |
| The class 'Hash' has a Standard Cyclomatic Complexity of 3 (Highest = 16). | 1145–1300 |
| The method 'compute' has a Modified Cyclomatic Complexity of 16. | 1187–1259 |
| The method 'compute' has a Cyclomatic Complexity of 17. | 1187–1259 |
| The method compute() has an NPath complexity of 1020 | 1187–1259 |
| The method 'compute' has a Standard Cyclomatic Complexity of 16. | 1187–1259 |
| Useless parentheses. | 1223 |
| Useless parentheses. | 1225 |
| Use block level rather than method level synchronization | 1318–1326 |
| Use block level rather than method level synchronization | 1329–1331 |
rdfpro-core - eu/fbk/rdfpro/ProcessorTBox.java
| Violation | Line |
|---|---|
| The class 'Handler' has a Modified Cyclomatic Complexity of 6 (Highest = 19). | 57–259 |
| The class 'Handler' has a Cyclomatic Complexity of 7 (Highest = 20). | 57–259 |
| The class 'Handler' has a Standard Cyclomatic Complexity of 6 (Highest = 19). | 57–259 |
| Avoid instantiating new objects inside loops | 70 |
| Avoid instantiating new objects inside loops | 79 |
| Avoid instantiating new objects inside loops | 82 |
| The method 'handleStatement' has a Cyclomatic Complexity of 12. | 92–144 |
| The method 'handleStatement' has a Modified Cyclomatic Complexity of 11. | 92–144 |
| The method 'handleStatement' has a Standard Cyclomatic Complexity of 11. | 92–144 |
| The method 'endRDF' has a Cyclomatic Complexity of 20. | 147–230 |
| The method 'endRDF' has a Modified Cyclomatic Complexity of 19. | 147–230 |
| The method 'endRDF' has a Standard Cyclomatic Complexity of 19. | 147–230 |
| The method endRDF() has an NPath complexity of 4225 | 147–230 |
rdfpro-core - eu/fbk/rdfpro/ProcessorUnique.java
| Violation | Line |
|---|---|
| Possible God class (WMC=57, ATFD=14, TCC=0.09090909090909091) | 14–690 |
| Document empty method body | 463–464 |
| The class 'MergeHandler' has a Cyclomatic Complexity of 6 (Highest = 12). | 468–688 |
| Ensure that resources like this Statement object are closed after use | 558 |
| Avoid instantiating new objects inside loops | 565 |
| Ensure that resources like this Statement object are closed after use | 567 |
| Ensure that resources like this Statement object are closed after use | 573 |
| Ensure that resources like this Statement object are closed after use | 581 |
| The method 'mergeContexts' has a Cyclomatic Complexity of 12. | 595–633 |
| Prefer StringBuffer over += for concatenating strings | 626 |
| The user-supplied array 'contexts' is stored directly. | 641 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 641 |
| Avoid using a branching statement as the last in a loop. | 676 |
rdfpro-core - eu/fbk/rdfpro/RDFHandlers.java
| Violation | Line |
|---|---|
| Possible God class (WMC=239, ATFD=64, TCC=0.046031746031746035) | 14–1651 |
| The class 'RDFHandlers' has a Cyclomatic Complexity of 4 (Highest = 13). | 76–1651 |
| The method write() has an NPath complexity of 270 | 186–199 |
| Avoid instantiating new objects inside loops | 194 |
| Avoid instantiating new objects inside loops | 195 |
| Overriding method merely calls super | 237–239 |
| Avoid using redundant field initializer for 'passHandler' | 271 |
| Avoid using redundant field initializer for 'pass' | 273 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 338 |
| The method 'collect' has a Cyclomatic Complexity of 13. | 401–434 |
| Avoid instantiating new objects inside loops | 429 |
| Use block level rather than method level synchronization | 505–516 |
| Use block level rather than method level synchronization | 519–522 |
| New exception is thrown in catch block, original stack trace may be lost | 559 |
| Use block level rather than method level synchronization | 565–567 |
| Use block level rather than method level synchronization | 570–573 |
| Use block level rather than method level synchronization | 576–579 |
| New exception is thrown in catch block, original stack trace may be lost | 641 |
| The class 'UpdateHandler' has a Cyclomatic Complexity of 4 (Highest = 10). | 694–835 |
| StringBuffers can grow quite a lot, and so may become a source of memory leak (if the owning class has a long life time). | 704 |
| Use block level rather than method level synchronization | 726–771 |
| The method 'handleStatement' has a Cyclomatic Complexity of 10. | 726–771 |
| The user-supplied array 'extraPasses' is stored directly. | 956 |
| The user-supplied array 'handlers' is stored directly. | 956 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 956 |
| The user-supplied array 'handlers' is stored directly. | 1036 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1036 |
| Document empty method body | 1169–1170 |
| Document empty method body | 1177–1178 |
| Document empty method body | 1180–1181 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1227 |
| Ensure that resources like this Statement object are closed after use | 1229 |
| Ensure that resources like this Statement object are closed after use | 1381 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1387 |
| Return an empty array rather than null. | 1387–1431 |
| Ensure that resources like this Statement object are closed after use | 1408 |
| Avoid empty catch blocks | 1484–1486 |
| Use block level rather than method level synchronization | 1516–1518 |
| Use block level rather than method level synchronization | 1521–1524 |
| Use block level rather than method level synchronization | 1527–1530 |
| The class 'DecoupleQueueHandler' has a Cyclomatic Complexity of 3 (Highest = 10). | 1534–1649 |
| The class 'DecoupleQueueHandler' has a Standard Cyclomatic Complexity of 3 (Highest = 10). | 1534–1649 |
| The class 'DecoupleQueueHandler' has a Modified Cyclomatic Complexity of 3 (Highest = 10). | 1534–1649 |
| The method 'startRDF' has a Standard Cyclomatic Complexity of 10. | 1554–1590 |
| The method 'startRDF' has a Cyclomatic Complexity of 10. | 1554–1590 |
| The method 'startRDF' has a Modified Cyclomatic Complexity of 10. | 1554–1590 |
| Avoid instantiating new objects inside loops | 1560–1588 |
rdfpro-core - eu/fbk/rdfpro/RDFProcessors.java
| Violation | Line |
|---|---|
| Possible God class (WMC=139, ATFD=77, TCC=0.02252252252252252) | 14–1162 |
| The class 'RDFProcessors' has a Cyclomatic Complexity of 4 (Highest = 32). | 56–1162 |
| The class 'RDFProcessors' has a Standard Cyclomatic Complexity of 3 (Highest = 32). | 56–1162 |
| The class 'RDFProcessors' has a Modified Cyclomatic Complexity of 3 (Highest = 21). | 56–1162 |
| The method 'tokenize' has a Cyclomatic Complexity of 10. | 85–126 |
| The method 'create' has a Cyclomatic Complexity of 32. | 139–368 |
| The method 'create' has a Standard Cyclomatic Complexity of 32. | 139–368 |
| The method 'create' has a Modified Cyclomatic Complexity of 21. | 139–368 |
| Avoid really long methods. | 139–368 |
| The method create() has an NCSS line count of 167 | 139–368 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 300 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 301–302 |
rdfpro-core - eu/fbk/rdfpro/RDFSource.java
| Violation | Line |
|---|---|
| Avoid really long methods. | 102–219 |
| The method spliterator() has an NPath complexity of 1282 | 102–219 |
| Avoid empty while statements | 123–124 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 148 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 150 |
| Use block level rather than method level synchronization | 236–239 |
rdfpro-core - eu/fbk/rdfpro/RDFSources.java
| Violation | Line |
|---|---|
| Possible God class (WMC=127, ATFD=119, TCC=0.0) | 14–856 |
| The class 'RDFSources' has a Modified Cyclomatic Complexity of 4 (Highest = 14). | 82–856 |
| The class 'RDFSources' has a Cyclomatic Complexity of 4 (Highest = 14). | 82–856 |
| The class 'RDFSources' has a Standard Cyclomatic Complexity of 4 (Highest = 14). | 82–856 |
| The method 'wrap' has a Standard Cyclomatic Complexity of 14. | 173–245 |
| The method 'wrap' has a Cyclomatic Complexity of 14. | 173–245 |
| The method 'wrap' has a Modified Cyclomatic Complexity of 14. | 173–245 |
| The method 'emit' has a Standard Cyclomatic Complexity of 11. | 181–230 |
| The method 'emit' has a Modified Cyclomatic Complexity of 11. | 181–230 |
| The method 'emit' has a Cyclomatic Complexity of 11. | 181–230 |
| Ensure that resources like this Statement object are closed after use | 221 |
| Avoid instantiating new objects inside loops | 269 |
| The class 'FileSource' has a Cyclomatic Complexity of 10 (Highest = 22). | 374–622 |
| The class 'FileSource' has a Standard Cyclomatic Complexity of 10 (Highest = 21). | 374–622 |
| The class 'FileSource' has a Modified Cyclomatic Complexity of 10 (Highest = 21). | 374–622 |
| The method 'parse' has a Cyclomatic Complexity of 22. | 428–527 |
| The method 'parse' has a Standard Cyclomatic Complexity of 21. | 428–527 |
| The method parse() has an NPath complexity of 38500 | 428–527 |
| The method 'parse' has a Modified Cyclomatic Complexity of 21. | 428–527 |
| Avoid empty catch blocks | 445–447 |
| Avoid calling toString() on String objects; this is unnecessary. | 467 |
| Avoid instantiating new objects inside loops | 467 |
| Avoid instantiating new objects inside loops | 480–508 |
| The class 'ParseJob' has a Modified Cyclomatic Complexity of 5 (Highest = 11). | 529–620 |
| The class 'ParseJob' has a Standard Cyclomatic Complexity of 5 (Highest = 11). | 529–620 |
| The class 'ParseJob' has a Cyclomatic Complexity of 5 (Highest = 12). | 529–620 |
| The method 'run' has a Modified Cyclomatic Complexity of 11. | 555–618 |
| The method 'run' has a Cyclomatic Complexity of 12. | 555–618 |
| The method 'run' has a Standard Cyclomatic Complexity of 11. | 555–618 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 605 |
| The class 'SparqlSource' has a Standard Cyclomatic Complexity of 6 (Highest = 16). | 624–854 |
| The class 'SparqlSource' has a Modified Cyclomatic Complexity of 6 (Highest = 16). | 624–854 |
| The class 'SparqlSource' has a Cyclomatic Complexity of 7 (Highest = 19). | 624–854 |
| The method 'parseTupleResult' has a Modified Cyclomatic Complexity of 16. | 745–802 |
| The method 'parseTupleResult' has a Cyclomatic Complexity of 19. | 745–802 |
| The method parseTupleResult() has an NPath complexity of 9396 | 745–802 |
| The method 'parseTupleResult' has a Standard Cyclomatic Complexity of 16. | 745–802 |
| Avoid empty while statements | 754–755 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 761 |
| Avoid empty while statements | 800–801 |
| The method 'isSelectQuery' has a Standard Cyclomatic Complexity of 10. | 822–852 |
| The method 'isSelectQuery' has a Modified Cyclomatic Complexity of 10. | 822–852 |
| The method 'isSelectQuery' has a Cyclomatic Complexity of 16. | 822–852 |
| Position literals first in String comparisons | 841 |
| Position literals first in String comparisons | 843 |
| Position literals first in String comparisons | 843 |
rdfpro-core - eu/fbk/rdfpro/Reducer.java
| Violation | Line |
|---|---|
| Ensure that resources like this Statement object are closed after use | 52 |
| Ensure that resources like this Statement object are closed after use | 86 |
| Ensure that resources like this Statement object are closed after use | 104 |
| Ensure that resources like this Statement object are closed after use | 121 |
rdfpro-core - eu/fbk/rdfpro/Rule.java
| Violation | Line |
|---|---|
| Possible God class (WMC=235, ATFD=111, TCC=0.001568627450980392) | 14–1433 |
| The class 'Rule' has a Modified Cyclomatic Complexity of 5 (Highest = 19). | 99–1433 |
| The class 'Rule' has a Cyclomatic Complexity of 5 (Highest = 25). | 99–1433 |
| The class 'Rule' has a Standard Cyclomatic Complexity of 5 (Highest = 19). | 99–1433 |
| Too many fields | 99–1433 |
| The method 'isSimple' has a Cyclomatic Complexity of 15. | 349–383 |
| The method 'isSimple' has a Standard Cyclomatic Complexity of 10. | 349–383 |
| The method 'isSimple' has a Modified Cyclomatic Complexity of 10. | 349–383 |
| The method 'meetNode' has a Cyclomatic Complexity of 11. | 356–376 |
| Prefer StringBuffer over += for concatenating strings | 549 |
| Avoid using a branching statement as the last in a loop. | 553 |
| The method mergeSameWhereExpr() has an NPath complexity of 381 | 627–664 |
| Avoid instantiating new objects inside loops | 635 |
| Avoid instantiating new objects inside loops | 646 |
| Avoid instantiating new objects inside loops | 655 |
| Avoid instantiating new objects inside loops | 657 |
| Avoid instantiating new objects inside loops | 660–661 |
| Avoid instantiating new objects inside loops | 682–683 |
| Avoid instantiating new objects inside loops | 689–690 |
| The method toString() has an NPath complexity of 201 | 765–791 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 768–769 |
| The method 'fromDLOG' has a Standard Cyclomatic Complexity of 16. | 828–909 |
| The method 'fromDLOG' has a Cyclomatic Complexity of 17. | 828–909 |
| The method 'fromDLOG' has a Modified Cyclomatic Complexity of 16. | 828–909 |
| The method fromDLOG() has an NPath complexity of 1369 | 828–909 |
| Avoid using redundant field initializer for 'namespaces' | 835 |
| Avoid using redundant field initializer for 'varCounter' | 839 |
| This call to String.startsWith can be rewritten using String.charAt(0) | 883 |
| The method fromRDF() has an NPath complexity of 3690 | 918–998 |
| The method 'fromRDF' has a Modified Cyclomatic Complexity of 19. | 918–998 |
| The method 'fromRDF' has a Cyclomatic Complexity of 25. | 918–998 |
| The method 'fromRDF' has a Standard Cyclomatic Complexity of 19. | 918–998 |
| Ensure that resources like this Statement object are closed after use | 927 |
| Ensure that resources like this Statement object are closed after use | 939 |
| Avoid instantiating new objects inside loops | 977 |
| Avoid instantiating new objects inside loops | 994–995 |
| The class 'Evaluation' has a Cyclomatic Complexity of 5 (Highest = 16). | 1017–1246 |
| The class 'Evaluation' has a Modified Cyclomatic Complexity of 5 (Highest = 14). | 1017–1246 |
| The class 'Evaluation' has a Standard Cyclomatic Complexity of 5 (Highest = 14). | 1017–1246 |
| The method 'run' has a Cyclomatic Complexity of 16. | 1073–1170 |
| The method run() has an NPath complexity of 1802 | 1073–1170 |
| The method 'run' has a Modified Cyclomatic Complexity of 14. | 1073–1170 |
| The method 'run' has a Standard Cyclomatic Complexity of 14. | 1073–1170 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1084 |
| Avoid using redundant field initializer for 'normalizedDeltaPattern' | 1198 |
| These nested if statements could be combined | 1206–1208 |
| The class 'Collector' has a Cyclomatic Complexity of 7 (Highest = 19). | 1248–1431 |
| The class 'Collector' has a Standard Cyclomatic Complexity of 6 (Highest = 12). | 1248–1431 |
| The class 'Collector' has a Modified Cyclomatic Complexity of 6 (Highest = 12). | 1248–1431 |
| Avoid appending characters as strings in StringBuffer.append. | 1285 |
| The user-supplied array 'insertIndexes' is stored directly. | 1336 |
| The user-supplied array 'deleteIndexes' is stored directly. | 1336 |
| The user-supplied array 'constants' is stored directly. | 1337 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1337 |
| The user-supplied array 'commonVars' is stored directly. | 1337 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1346 |
| The method 'collect' has a Modified Cyclomatic Complexity of 12. | 1351–1410 |
| The method 'collect' has a Standard Cyclomatic Complexity of 12. | 1351–1410 |
| The method 'collect' has a Cyclomatic Complexity of 19. | 1351–1410 |
| Avoid instantiating new objects inside loops | 1377–1378 |
| Ensure that resources like this Statement object are closed after use | 1380 |
| Avoid instantiating new objects inside loops | 1382–1383 |
| Avoid instantiating new objects inside loops | 1400–1401 |
rdfpro-core - eu/fbk/rdfpro/RuleEngine.java
| Violation | Line |
|---|---|
| This abstract class does not have any abstract methods | 45–327 |
| New exception is thrown in catch block, original stack trace may be lost | 113 |
| Ensure that resources like this Statement object are closed after use | 249 |
| Ensure that resources like this Statement object are closed after use | 269 |
| Ensure that resources like this Statement object are closed after use | 279 |
| Use block level rather than method level synchronization | 309–312 |
| Ensure that resources like this Statement object are closed after use | 317 |
rdfpro-core - eu/fbk/rdfpro/RuleEngineImpl.java
| Violation | Line |
|---|---|
| Possible God class (WMC=182, ATFD=92, TCC=0.015789473684210527) | 14–1152 |
| The class 'RuleEngineImpl' has a Cyclomatic Complexity of 8 (Highest = 22). | 49–1152 |
| The class 'RuleEngineImpl' has a Modified Cyclomatic Complexity of 7 (Highest = 17). | 49–1152 |
| The class 'RuleEngineImpl' has a Standard Cyclomatic Complexity of 7 (Highest = 17). | 49–1152 |
| StringBuffer constructor is initialized with size 16, but has at least 19 characters appended. | 81 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 94 |
| The method doEval() has an NPath complexity of 432 | 116–184 |
| The method 'doEval' has a Standard Cyclomatic Complexity of 12. | 116–184 |
| The method 'doEval' has a Cyclomatic Complexity of 15. | 116–184 |
| The method 'doEval' has a Modified Cyclomatic Complexity of 12. | 116–184 |
| Ensure that resources like this Statement object are closed after use | 167 |
| The method 'expand' has a Modified Cyclomatic Complexity of 17. | 186–282 |
| The method 'expand' has a Standard Cyclomatic Complexity of 17. | 186–282 |
| The method expand() has an NPath complexity of 2256 | 186–282 |
| The method 'expand' has a Cyclomatic Complexity of 22. | 186–282 |
| Ensure that resources like this Statement object are closed after use | 218 |
| Ensure that resources like this Statement object are closed after use | 231 |
| Ensure that resources like this Statement object are closed after use | 245 |
| Avoid instantiating new objects inside loops | 260 |
| Avoid reassigning parameters such as 'statements' | 284 |
| Ensure that resources like this Statement object are closed after use | 290 |
| This abstract class does not have any abstract methods | 347–382 |
| The class 'StreamPhase' has a Cyclomatic Complexity of 6 (Highest = 17). | 384–531 |
| The class 'StreamPhase' has a Standard Cyclomatic Complexity of 5 (Highest = 14). | 384–531 |
| The class 'StreamPhase' has a Modified Cyclomatic Complexity of 5 (Highest = 14). | 384–531 |
| The user-supplied array 'axioms' is stored directly. | 397 |
| The method 'create' has a Cyclomatic Complexity of 17. | 410–467 |
| The method create() has an NPath complexity of 9450 | 410–467 |
| The method 'create' has a Standard Cyclomatic Complexity of 14. | 410–467 |
| The method 'create' has a Modified Cyclomatic Complexity of 14. | 410–467 |
| Avoid instantiating new objects inside loops | 428 |
| Ensure that resources like this Statement object are closed after use | 484 |
| Ensure that resources like this Statement object are closed after use | 514 |
| The method eval() has an NPath complexity of 200 | 583–606 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 612 |
| The class 'SemiNaivePhase' has a Modified Cyclomatic Complexity of 4 (Highest = 12). | 673–1150 |
| The class 'SemiNaivePhase' has a Cyclomatic Complexity of 4 (Highest = 15). | 673–1150 |
| The class 'SemiNaivePhase' has a Standard Cyclomatic Complexity of 4 (Highest = 12). | 673–1150 |
| The user-supplied array 'axioms' is stored directly. | 689 |
| The method create() has an NPath complexity of 806 | 700–755 |
| The method 'create' has a Cyclomatic Complexity of 15. | 700–755 |
| The method 'create' has a Standard Cyclomatic Complexity of 12. | 700–755 |
| The method 'create' has a Modified Cyclomatic Complexity of 12. | 700–755 |
| Avoid instantiating new objects inside loops | 723 |
| Ensure that resources like this Statement object are closed after use | 767 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 824 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 866 |
| Avoid instantiating new objects inside loops | 979–987 |
| Ensure that resources like this Statement object are closed after use | 1046 |
| Ensure that resources like this Statement object are closed after use | 1116 |
rdfpro-core - eu/fbk/rdfpro/Ruleset.java
| Violation | Line |
|---|---|
| Possible God class (WMC=89, ATFD=52, TCC=0.005263157894736842) | 14–669 |
| The class 'Ruleset' has a Standard Cyclomatic Complexity of 4 (Highest = 14). | 57–669 |
| The class 'Ruleset' has a Cyclomatic Complexity of 4 (Highest = 19). | 57–669 |
| The class 'Ruleset' has a Modified Cyclomatic Complexity of 4 (Highest = 14). | 57–669 |
| The method isMatchable() has an NPath complexity of 8784 | 200–273 |
| The method 'isMatchable' has a Cyclomatic Complexity of 19. | 200–273 |
| The method 'isMatchable' has a Modified Cyclomatic Complexity of 14. | 200–273 |
| The method 'isMatchable' has a Standard Cyclomatic Complexity of 14. | 200–273 |
| Deeply nested if..then statements are hard to read | 216–222 |
| Avoid instantiating new objects inside loops | 219 |
| Deeply nested if..then statements are hard to read | 231–233 |
| Deeply nested if..then statements are hard to read | 236–244 |
| Deeply nested if..then statements are hard to read | 249–253 |
| The method 'getABoxRuleset' has a Standard Cyclomatic Complexity of 13. | 292–365 |
| The method 'getABoxRuleset' has a Modified Cyclomatic Complexity of 13. | 292–365 |
| The method 'getABoxRuleset' has a Cyclomatic Complexity of 16. | 292–365 |
| Avoid instantiating new objects inside loops | 298 |
| Avoid instantiating new objects inside loops | 311–320 |
| Avoid instantiating new objects inside loops | 335–336 |
| Deeply nested if..then statements are hard to read | 350–353 |
| Avoid instantiating new objects inside loops | 352 |
| StringBuffer constructor is initialized with size 16, but has at least 42 characters appended. | 494 |
| Avoid appending characters as strings in StringBuffer.append. | 498 |
| Avoid appending characters as strings in StringBuffer.append. | 503 |
| Ensure that resources like this Statement object are closed after use | 544 |
| StringBuffer constructor is initialized with size 16, but has at least 18 characters appended. | 646 |
rdfpro-core - eu/fbk/rdfpro/SetOperator.java
| Violation | Line |
|---|---|
| Possible God class (WMC=55, ATFD=14, TCC=0.0) | 14–407 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 36 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 58 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 82 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 102 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 124 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 147 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 175 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 196 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 222 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 258 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 290 |
| Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 301 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 321 |
rdfpro-core - eu/fbk/rdfpro/StatementBuffer.java
| Violation | Line |
|---|---|
| Possible God class (WMC=63, ATFD=19, TCC=0.24183006535947713) | 14–458 |
| The class 'StatementBuffer' has a Standard Cyclomatic Complexity of 4 (Highest = 11). | 45–458 |
| The class 'StatementBuffer' has a Cyclomatic Complexity of 4 (Highest = 11). | 45–458 |
| The class 'StatementBuffer' has a Modified Cyclomatic Complexity of 4 (Highest = 11). | 45–458 |
| Ensure that resources like this Statement object are closed after use | 114 |
| The method iterator() has an NPath complexity of 350 | 120–170 |
| Avoid using redundant field initializer for 'index' | 126 |
| Avoid using redundant field initializer for 'offset' | 128 |
| The method 'toModel' has a Standard Cyclomatic Complexity of 11. | 172–241 |
| The method toModel() has an NPath complexity of 730 | 172–241 |
| The method 'toModel' has a Cyclomatic Complexity of 11. | 172–241 |
| The method 'toModel' has a Modified Cyclomatic Complexity of 11. | 172–241 |
| Avoid instantiating new objects inside loops | 219 |
| Avoid instantiating new objects inside loops | 251–252 |
| Use block level rather than method level synchronization | 258–288 |
| Avoid instantiation through private constructors from outside of the constructors class. | 297 |
| Use block level rather than method level synchronization | 327–334 |
| Use block level rather than method level synchronization | 336–342 |
| Use block level rather than method level synchronization | 344–386 |
| Avoid instantiating new objects inside loops | 371 |
rdfpro-core - eu/fbk/rdfpro/Transformer.java
| Violation | Line |
|---|---|
| Possible God class (WMC=161, ATFD=40, TCC=0.10909090909090909) | 14–843 |
| Avoid modifiers which are implied by the context | 88–94 |
| Document empty method body | 91–92 |
| Avoid modifiers which are implied by the context | 97–105 |
| The method filter() has an NPath complexity of 4160 | 144–186 |
| Ensure that resources like this Statement object are closed after use | 205 |
| The method map() has an NPath complexity of 63180 | 228–318 |
| The method transform() has an NPath complexity of 243 | 260–315 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 264 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 265 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 266 |
| The method set() has an NPath complexity of 65520 | 338–400 |
| The method transform() has an NPath complexity of 1250 | 382–396 |
| Ensure that resources like this Statement object are closed after use | 431 |
| The class 'RuleTransformer' has a Cyclomatic Complexity of 19 (Highest = 22). | 547–843 |
| The class 'RuleTransformer' has a Standard Cyclomatic Complexity of 16 (Highest = 19). | 547–843 |
| The class 'RuleTransformer' has a Modified Cyclomatic Complexity of 16 (Highest = 19). | 547–843 |
| The constructor 'RuleTransformer' has a Modified Cyclomatic Complexity of 19. | 562–626 |
| The constructor 'RuleTransformer' has a Cyclomatic Complexity of 22. | 562–626 |
| The constructor 'RuleTransformer' has a Standard Cyclomatic Complexity of 19. | 562–626 |
| Avoid instantiating new objects inside loops | 569 |
| Avoid instantiating new objects inside loops | 619–620 |
| The method 'transform' has a Cyclomatic Complexity of 15. | 629–683 |
| The method transform() has an NPath complexity of 2430 | 629–683 |
| The method 'transform' has a Standard Cyclomatic Complexity of 12. | 629–683 |
| The method 'transform' has a Modified Cyclomatic Complexity of 12. | 629–683 |
| The class 'ValueTransformer' has a Modified Cyclomatic Complexity of 6 (Highest = 15). | 685–841 |
| The class 'ValueTransformer' has a Cyclomatic Complexity of 6 (Highest = 15). | 685–841 |
| The class 'ValueTransformer' has a Standard Cyclomatic Complexity of 6 (Highest = 15). | 685–841 |
| The constructor 'ValueTransformer' has a Modified Cyclomatic Complexity of 15. | 722–788 |
| The constructor 'ValueTransformer' has a Cyclomatic Complexity of 15. | 722–788 |
| The constructor 'ValueTransformer' has a Standard Cyclomatic Complexity of 15. | 722–788 |
rdfpro-core - eu/fbk/rdfpro/internal/FunctionCompatibleDatatype.java
| Violation | Line |
|---|---|
| Avoid instantiating new objects inside loops | 84 |
| Avoid instantiating new objects inside loops | 88 |
| Avoid instantiating new objects inside loops | 109 |
rdfpro-core - eu/fbk/rdfpro/internal/FunctionMint.java
| Violation | Line |
|---|---|
| The class 'FunctionMint' has a Standard Cyclomatic Complexity of 8 (Highest = 13). | 30–101 |
| The class 'FunctionMint' has a Cyclomatic Complexity of 8 (Highest = 15). | 30–101 |
| The class 'FunctionMint' has a Modified Cyclomatic Complexity of 8 (Highest = 13). | 30–101 |
| The method 'evaluate' has a Cyclomatic Complexity of 15. | 40–99 |
| The method 'evaluate' has a Modified Cyclomatic Complexity of 13. | 40–99 |
| The method 'evaluate' has a Standard Cyclomatic Complexity of 13. | 40–99 |
rdfpro-core - eu/fbk/rdfpro/util/Algebra.java
| Violation | Line |
|---|---|
| Possible God class (WMC=183, ATFD=116, TCC=0.0033613445378151263) | 14–973 |
| The class 'Algebra' has a Modified Cyclomatic Complexity of 5 (Highest = 23). | 113–973 |
| The class 'Algebra' has a Standard Cyclomatic Complexity of 5 (Highest = 23). | 113–973 |
| 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. | 113–973 |
| The class 'Algebra' has a Cyclomatic Complexity of 6 (Highest = 32). | 113–973 |
| The method 'parseQuery' has a Modified Cyclomatic Complexity of 14. | 213–279 |
| The method 'parseQuery' has a Standard Cyclomatic Complexity of 14. | 213–279 |
| The method 'parseQuery' has a Cyclomatic Complexity of 14. | 213–279 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 225 |
| Avoid reassigning parameters such as 'expr' | 292 |
| Avoid reassigning parameters such as 'expr' | 315 |
| The method 'evaluateTupleExpr' has a Standard Cyclomatic Complexity of 10. | 315–375 |
| Avoid reassigning parameters such as 'expr' | 315 |
| The method 'evaluateTupleExpr' has a Cyclomatic Complexity of 10. | 315–375 |
| The method 'evaluateTupleExpr' has a Modified Cyclomatic Complexity of 10. | 315–375 |
| The method evaluateTupleExpr() has an NPath complexity of 1500 | 315–375 |
| Avoid reassigning parameters such as 'bindings' | 316 |
| Avoid reassigning parameters such as 'evaluationStrategy' | 317 |
| Avoid reassigning parameters such as 'evaluationStatistics' | 318 |
| The method 'normalizeVars' has a Cyclomatic Complexity of 20. | 516–580 |
| The method 'normalizeVars' has a Modified Cyclomatic Complexity of 16. | 516–580 |
| The method normalizeVars() has an NPath complexity of 280 | 516–580 |
| Avoid reassigning parameters such as 'expr' | 516 |
| Avoid reassigning parameters such as 'expr' | 516 |
| The method 'normalizeVars' has a Standard Cyclomatic Complexity of 16. | 516–580 |
| The method 'meet' has a Cyclomatic Complexity of 10. | 550–573 |
| Avoid reassigning parameters such as 'expr' | 616 |
| Avoid reassigning parameters such as 'expr' | 616 |
| Avoid instantiating new objects inside loops | 637 |
| Avoid reassigning parameters such as 'expr' | 646 |
| Avoid reassigning parameters such as 'expr' | 646 |
| The method 'pushFilters' has a Standard Cyclomatic Complexity of 12. | 646–703 |
| Avoid reassigning parameters such as 'expr' | 646 |
| The method 'pushFilters' has a Modified Cyclomatic Complexity of 12. | 646–703 |
| The method 'pushFilters' has a Cyclomatic Complexity of 12. | 646–703 |
| Avoid instantiating new objects inside loops | 671 |
| Avoid instantiating new objects inside loops | 675 |
| The method 'pushExtensions' has a Standard Cyclomatic Complexity of 13. | 706–753 |
| The method 'pushExtensions' has a Modified Cyclomatic Complexity of 13. | 706–753 |
| Avoid reassigning parameters such as 'expr' | 706 |
| Avoid reassigning parameters such as 'expr' | 706 |
| The method 'pushExtensions' has a Cyclomatic Complexity of 13. | 706–753 |
| Avoid instantiating new objects inside loops | 727 |
| Avoid instantiating new objects inside loops | 732 |
| Avoid instantiating new objects inside loops | 736 |
| The method 'splitTupleExpr' has a Standard Cyclomatic Complexity of 23. | 773–883 |
| The method 'splitTupleExpr' has a Cyclomatic Complexity of 32. | 773–883 |
| The method splitTupleExpr() has an NPath complexity of 618 | 773–883 |
| The method 'splitTupleExpr' has a Modified Cyclomatic Complexity of 23. | 773–883 |
| Avoid really long methods. | 773–883 |
| Avoid using redundant field initializer for 'flag' | 789 |
| Avoid instantiating new objects inside loops | 833 |
| Avoid instantiating new objects inside loops | 851 |
| Avoid instantiating new objects inside loops | 867 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 925 |
rdfpro-core - eu/fbk/rdfpro/util/Buffer.java
| Violation | Line |
|---|---|
| The class 'FixedBuffer' has a Cyclomatic Complexity of 3 (Highest = 11). | 57–248 |
| The user-supplied array 'buffer' is stored directly. | 61 |
| Avoid reassigning parameters such as 'length' | 166 |
| The method 'equalString' has a Cyclomatic Complexity of 11. | 211–246 |
| The class 'ResizableBuffer' has a Modified Cyclomatic Complexity of 3 (Highest = 10). | 250–571 |
| The class 'ResizableBuffer' has a Cyclomatic Complexity of 4 (Highest = 12). | 250–571 |
| The class 'ResizableBuffer' has a Standard Cyclomatic Complexity of 3 (Highest = 10). | 250–571 |
| Avoid reassigning parameters such as 'length' | 410 |
| Avoid reassigning parameters such as 'index' | 410 |
| Avoid reassigning parameters such as 'length' | 429 |
| Avoid instantiating new objects inside loops | 486 |
| The method 'equalString' has a Standard Cyclomatic Complexity of 10. | 500–545 |
| The method 'equalString' has a Modified Cyclomatic Complexity of 10. | 500–545 |
| The method 'equalString' has a Cyclomatic Complexity of 12. | 500–545 |
| Use block level rather than method level synchronization | 559–569 |
rdfpro-core - eu/fbk/rdfpro/util/Dictionary.java
| Violation | Line |
|---|---|
| Possible God class (WMC=187, ATFD=95, TCC=0.01904761904761905) | 14–1055 |
| The class 'Dictionary' has a Standard Cyclomatic Complexity of 4 (Highest = 18). | 45–1055 |
| The class 'Dictionary' has a Cyclomatic Complexity of 4 (Highest = 26). | 45–1055 |
| The class 'Dictionary' has a Modified Cyclomatic Complexity of 3 (Highest = 13). | 45–1055 |
| Document empty method body | 178–179 |
| Document empty method body | 181–182 |
| The method 'encode' has a Cyclomatic Complexity of 15. | 246–315 |
| The method 'encode' has a Standard Cyclomatic Complexity of 13. | 246–315 |
| The method 'encode' has a Modified Cyclomatic Complexity of 13. | 246–315 |
| The method encode() has an NPath complexity of 280 | 246–315 |
| StringBuffer constructor is initialized with size 18, but has at least 41 characters appended. | 409 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 412 |
| Avoid appending characters as strings in StringBuffer.append. | 427 |
| The method 'pack' has a Modified Cyclomatic Complexity of 13. | 432–492 |
| The method 'pack' has a Cyclomatic Complexity of 26. | 432–492 |
| The method 'pack' has a Standard Cyclomatic Complexity of 18. | 432–492 |
| Switch statements should have a default label | 434–488 |
| The method 'unpack' has a Cyclomatic Complexity of 11. | 494–527 |
| The method 'unpack' has a Standard Cyclomatic Complexity of 11. | 494–527 |
| Useless parentheses. | 498 |
| Useless parentheses. | 499 |
| Useless parentheses. | 503 |
| Useless parentheses. | 506 |
| Avoid modifiers which are implied by the context | 539–545 |
| Document empty method body | 542–543 |
| Document empty method body | 547–548 |
| Document empty method body | 552–553 |
| Document empty method body | 556–557 |
| The class 'SequentialDictionary' has a Standard Cyclomatic Complexity of 3 (Highest = 10). | 590–692 |
| The class 'SequentialDictionary' has a Cyclomatic Complexity of 3 (Highest = 11). | 590–692 |
| The class 'SequentialDictionary' has a Modified Cyclomatic Complexity of 3 (Highest = 10). | 590–692 |
| The method 'encode' has a Cyclomatic Complexity of 11. | 618–659 |
| The method 'encode' has a Standard Cyclomatic Complexity of 10. | 618–659 |
| The method 'encode' has a Modified Cyclomatic Complexity of 10. | 618–659 |
| The class 'MemoryDictionary' has a Modified Cyclomatic Complexity of 5 (Highest = 10). | 699–1053 |
| The class 'MemoryDictionary' has a Standard Cyclomatic Complexity of 5 (Highest = 10). | 699–1053 |
| The class 'MemoryDictionary' has a Cyclomatic Complexity of 5 (Highest = 12). | 699–1053 |
| Avoid instantiating new objects inside loops | 724 |
| Avoid instantiating new objects inside loops | 741 |
| The method 'doEncode2' has a Modified Cyclomatic Complexity of 10. | 767–817 |
| The method 'doEncode2' has a Standard Cyclomatic Complexity of 10. | 767–817 |
| The method 'doEncode2' has a Cyclomatic Complexity of 12. | 767–817 |
| Avoid instantiating new objects inside loops | 777 |
| Avoid reassigning parameters such as 'bufferStart' | 899 |
| Avoid reassigning parameters such as 'bufferStart' | 899 |
| The method append() has an NPath complexity of 6260 | 899–940 |
| Avoid reassigning parameters such as 'bufferLength' | 900 |
| The method 'append2' has a Standard Cyclomatic Complexity of 10. | 942–989 |
| The method 'append2' has a Cyclomatic Complexity of 10. | 942–989 |
| The method 'append2' has a Modified Cyclomatic Complexity of 10. | 942–989 |
| The method append2() has an NPath complexity of 37800 | 942–989 |
| Avoid reassigning parameters such as 'offset' | 991 |
| The method equals() has an NPath complexity of 260 | 991–1035 |
| Avoid reassigning parameters such as 'offset' | 991 |
rdfpro-core - eu/fbk/rdfpro/util/Environment.java
| Violation | Line |
|---|---|
| Possible God class (WMC=74, ATFD=47, TCC=0.14545454545454545) | 14–408 |
| The class 'Environment' has a Standard Cyclomatic Complexity of 6 (Highest = 14). | 54–408 |
| The class 'Environment' has a Modified Cyclomatic Complexity of 6 (Highest = 14). | 54–408 |
| 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. | 54–408 |
| The class 'Environment' has a Cyclomatic Complexity of 7 (Highest = 16). | 54–408 |
| Avoid using redundant field initializer for 'configuredPool' | 67 |
| Avoid using redundant field initializer for 'frozenPool' | 69 |
| Avoid using redundant field initializer for 'frozenPlugins' | 71 |
| Avoid using redundant field initializer for 'frozenCores' | 73 |
| Do not add empty strings | 77 |
| Avoid instantiating new objects inside loops | 85 |
| Avoid instantiating new objects inside loops | 92 |
| Singleton is not thread safe | 153–178 |
| The method 'run' has a Modified Cyclomatic Complexity of 10. | 182–229 |
| The method 'run' has a Cyclomatic Complexity of 11. | 182–229 |
| The method 'run' has a Standard Cyclomatic Complexity of 10. | 182–229 |
| Avoid instantiating new objects inside loops | 193–212 |
| Avoid instantiating new objects inside loops | 318 |
| The method 'loadPlugins' has a Standard Cyclomatic Complexity of 14. | 328–390 |
| The method 'loadPlugins' has a Modified Cyclomatic Complexity of 14. | 328–390 |
| The method 'loadPlugins' has a Cyclomatic Complexity of 16. | 328–390 |
| Position literals first in String comparisons for EqualsIgnoreCase | 343 |
| Avoid instantiating new objects inside loops | 356 |
| Avoid instantiating new objects inside loops | 372 |
rdfpro-core - eu/fbk/rdfpro/util/Hash.java
| Violation | Line |
|---|---|
| The class 'Hash' has a Cyclomatic Complexity of 3 (Highest = 10). | 19–200 |
| The method 'murmur3' has a Cyclomatic Complexity of 10. | 49–127 |
rdfpro-core - eu/fbk/rdfpro/util/HashValueFactory.java
| Violation | Line |
|---|---|
| Possible God class (WMC=84, ATFD=137, TCC=0.0) | 14–488 |
| Avoid instantiating new objects inside loops | 79 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 339 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 340 |
| Avoid appending characters as strings in StringBuffer.append. | 351 |
rdfpro-core - eu/fbk/rdfpro/util/IO.java
| Violation | Line |
|---|---|
| Possible God class (WMC=375, ATFD=44, TCC=0.017825311942959002) | 14–2160 |
| The class 'IO' has a Modified Cyclomatic Complexity of 3 (Highest = 14). | 51–2160 |
| The class 'IO' has a Standard Cyclomatic Complexity of 3 (Highest = 14). | 51–2160 |
| The class 'IO' has a Cyclomatic Complexity of 3 (Highest = 14). | 51–2160 |
| Do not add empty strings | 67 |
| The method extractExtension() has an NPath complexity of 255 | 117–133 |
| The method 'read' has a Cyclomatic Complexity of 14. | 135–209 |
| The method 'read' has a Standard Cyclomatic Complexity of 14. | 135–209 |
| The method 'read' has a Modified Cyclomatic Complexity of 14. | 135–209 |
| New exception is thrown in catch block, original stack trace may be lost | 158 |
| Prefer StringBuffer over += for concatenating strings | 167 |
| The method 'write' has a Cyclomatic Complexity of 14. | 211–286 |
| The method 'write' has a Modified Cyclomatic Complexity of 14. | 211–286 |
| The method 'write' has a Standard Cyclomatic Complexity of 14. | 211–286 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 213 |
| New exception is thrown in catch block, original stack trace may be lost | 224 |
| The class 'SimpleBufferedInputStream' has a Cyclomatic Complexity of 3 (Highest = 14). | 342–470 |
| The class 'SimpleBufferedInputStream' has a Standard Cyclomatic Complexity of 3 (Highest = 13). | 342–470 |
| The class 'SimpleBufferedInputStream' has a Modified Cyclomatic Complexity of 3 (Highest = 13). | 342–470 |
| The method 'read' has a Standard Cyclomatic Complexity of 13. | 374–407 |
| Avoid reassigning parameters such as 'len' | 374 |
| The method 'read' has a Modified Cyclomatic Complexity of 13. | 374–407 |
| Avoid reassigning parameters such as 'off' | 374 |
| The method read() has an NPath complexity of 2052 | 374–407 |
| The method 'read' has a Cyclomatic Complexity of 14. | 374–407 |
| Document empty method body | 437–438 |
| Avoid reassigning parameters such as 'off' | 498 |
| Avoid reassigning parameters such as 'len' | 498 |
| Document empty method body | 623–624 |
| Avoid reassigning parameters such as 'off' | 685 |
| Avoid reassigning parameters such as 'len' | 685 |
| Avoid reassigning parameters such as 'len' | 704 |
| Avoid reassigning parameters such as 'off' | 704 |
| Document empty method body | 832–833 |
| The class 'Fetcher' has a Cyclomatic Complexity of 4 (Highest = 11). | 878–1072 |
| The class 'Fetcher' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 878–1072 |
| The class 'Fetcher' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 878–1072 |
| The method 'run' has a Standard Cyclomatic Complexity of 10. | 993–1056 |
| The method 'run' has a Cyclomatic Complexity of 11. | 993–1056 |
| The method 'run' has a Modified Cyclomatic Complexity of 10. | 993–1056 |
| Avoid instantiating new objects inside loops | 1027 |
| Avoid instantiation through private constructors from outside of the constructors class. | 1062 |
| Avoid reassigning parameters such as 'off' | 1113 |
| Avoid reassigning parameters such as 'off' | 1113 |
| Avoid reassigning parameters such as 'len' | 1113 |
| Avoid reassigning parameters such as 'off' | 1133 |
| Avoid reassigning parameters such as 'len' | 1133 |
| Avoid reassigning parameters such as 'off' | 1133 |
| Avoid instantiation through private constructors from outside of the constructors class. | 1348 |
| Document empty method body | 1441–1442 |
| The class 'Fetcher' has a Cyclomatic Complexity of 4 (Highest = 12). | 1487–1688 |
| The class 'Fetcher' has a Modified Cyclomatic Complexity of 4 (Highest = 11). | 1487–1688 |
| The class 'Fetcher' has a Standard Cyclomatic Complexity of 4 (Highest = 11). | 1487–1688 |
| The method 'run' has a Cyclomatic Complexity of 12. | 1602–1672 |
| The method 'run' has a Standard Cyclomatic Complexity of 11. | 1602–1672 |
| The method 'run' has a Modified Cyclomatic Complexity of 11. | 1602–1672 |
| Avoid instantiating new objects inside loops | 1643 |
| Avoid instantiation through private constructors from outside of the constructors class. | 1678 |
| Avoid reassigning parameters such as 'off' | 1729 |
| Avoid reassigning parameters such as 'len' | 1729 |
| Avoid reassigning parameters such as 'off' | 1729 |
| Avoid instantiation through private constructors from outside of the constructors class. | 1942 |
| The class 'UTF8Reader' has a Cyclomatic Complexity of 3 (Highest = 11). | 1953–2082 |
| The method 'readHelper' has a Cyclomatic Complexity of 11. | 1970–2000 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 2011 |
| Document empty method body | 2057–2058 |
rdfpro-core - eu/fbk/rdfpro/util/Iterators.java
| Violation | Line |
|---|---|
| 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. | 30–346 |
rdfpro-core - eu/fbk/rdfpro/util/Namespaces.java
| Violation | Line |
|---|---|
| Possible God class (WMC=85, ATFD=30, TCC=0.0) | 14–609 |
| The class 'Namespaces' has a Cyclomatic Complexity of 3 (Highest = 10). | 72–609 |
| The method insert() has an NPath complexity of 510 | 152–190 |
| The method 'insert' has a Cyclomatic Complexity of 10. | 152–190 |
| Avoid instantiating new objects inside loops | 237–238 |
| Avoid instantiating new objects inside loops | 244 |
| Avoid instantiating new objects inside loops | 278 |
| Avoid instantiating new objects inside loops | 303 |
| Avoid instantiating new objects inside loops | 336 |
rdfpro-core - eu/fbk/rdfpro/util/Options.java
| Violation | Line |
|---|---|
| Possible God class (WMC=69, ATFD=23, TCC=0.0) | 14–270 |
| The class 'Options' has a Cyclomatic Complexity of 4 (Highest = 29). | 24–270 |
| The class 'Options' has a Modified Cyclomatic Complexity of 4 (Highest = 27). | 24–270 |
| The class 'Options' has a Standard Cyclomatic Complexity of 4 (Highest = 27). | 24–270 |
| The method parse() has an NPath complexity of 6787161 | 32–129 |
| The method 'parse' has a Modified Cyclomatic Complexity of 27. | 32–129 |
| The method 'parse' has a Standard Cyclomatic Complexity of 27. | 32–129 |
| The method 'parse' has a Cyclomatic Complexity of 29. | 32–129 |
| Prefer StringBuffer over += for concatenating strings | 60 |
| Avoid instantiating new objects inside loops | 91 |
rdfpro-core - eu/fbk/rdfpro/util/QuadModel.java
| Violation | Line |
|---|---|
| Possible God class (WMC=195, ATFD=49, TCC=0.00816326530612245) | 14–1224 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 117 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 125 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 128 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 131 |
| Ensure that resources like this Statement object are closed after use | 271 |
| Ensure that resources like this Statement object are closed after use | 370 |
| Ensure that resources like this Statement object are closed after use | 413 |
| The method getEvaluationStatistics() has an NPath complexity of 628 | 773–793 |
| Avoid instantiation through private constructors from outside of the constructors class. | 830 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 933 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 945 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 951 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 957 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 996 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1008 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1014 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1020 |
| The class 'FilteredModel' has a Standard Cyclomatic Complexity of 3 (Highest = 13). | 1038–1222 |
| The class 'FilteredModel' has a Modified Cyclomatic Complexity of 3 (Highest = 13). | 1038–1222 |
| The class 'FilteredModel' has a Cyclomatic Complexity of 4 (Highest = 13). | 1038–1222 |
| The user-supplied array 'contexts' is stored directly. | 1058 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1058 |
| Avoid reassigning parameters such as 'obj' | 1082 |
| Avoid reassigning parameters such as 'pred' | 1082 |
| Avoid reassigning parameters such as 'subj' | 1082 |
| Avoid reassigning parameters such as 'ctxs' | 1083 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1083 |
| Avoid reassigning parameters such as 'subj' | 1095 |
| Avoid reassigning parameters such as 'pred' | 1095 |
| Avoid reassigning parameters such as 'obj' | 1096 |
| Avoid reassigning parameters such as 'subj' | 1120 |
| Avoid reassigning parameters such as 'pred' | 1120 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1121 |
| Avoid reassigning parameters such as 'obj' | 1121 |
| Avoid reassigning parameters such as 'ctxs' | 1121 |
| Avoid reassigning parameters such as 'pred' | 1133 |
| Avoid reassigning parameters such as 'subj' | 1133 |
| Avoid reassigning parameters such as 'obj' | 1133 |
| Avoid reassigning parameters such as 'ctxs' | 1134 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1134 |
| Avoid reassigning parameters such as 'pred' | 1149 |
| Avoid reassigning parameters such as 'subj' | 1149 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1150 |
| Avoid reassigning parameters such as 'ctxs' | 1150 |
| Avoid reassigning parameters such as 'obj' | 1150 |
| Avoid reassigning parameters such as 'obj' | 1162 |
| Avoid reassigning parameters such as 'pred' | 1162 |
| Avoid reassigning parameters such as 'subj' | 1162 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 1186 |
| The method filter() has an NPath complexity of 435 | 1186–1220 |
| The method 'filter' has a Standard Cyclomatic Complexity of 13. | 1186–1220 |
| The method 'filter' has a Cyclomatic Complexity of 13. | 1186–1220 |
| The method 'filter' has a Modified Cyclomatic Complexity of 13. | 1186–1220 |
| Avoid instantiating new objects inside loops | 1202 |
| Avoid using a branching statement as the last in a loop. | 1215–1216 |
rdfpro-core - eu/fbk/rdfpro/util/QuadModelImpl.java
| Violation | Line |
|---|---|
| Possible God class (WMC=285, ATFD=115, TCC=0.008627450980392156) | 14–1467 |
| Too many fields | 49–1467 |
| The class 'QuadModelImpl' has a Cyclomatic Complexity of 8 (Highest = 26). | 49–1467 |
| The class 'QuadModelImpl' has a Standard Cyclomatic Complexity of 6 (Highest = 22). | 49–1467 |
| The class 'QuadModelImpl' has a Modified Cyclomatic Complexity of 6 (Highest = 22). | 49–1467 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 137 |
| The method doIterator() has an NPath complexity of 204 | 189–227 |
| The method 'doIterator' has a Cyclomatic Complexity of 10. | 189–227 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 190 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 231 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 264 |
| Use block level rather than method level synchronization | 300–302 |
| The method 'doIterator' has a Modified Cyclomatic Complexity of 22. | 348–451 |
| The method 'doIterator' has a Cyclomatic Complexity of 26. | 348–451 |
| The method doIterator() has an NPath complexity of 26520 | 348–451 |
| The method 'doIterator' has a Standard Cyclomatic Complexity of 22. | 348–451 |
| Avoid really long methods. | 348–451 |
| Avoid using redundant field initializer for 'index' | 360 |
| Avoid using redundant field initializer for 'next' | 362 |
| Avoid using redundant field initializer for 'last' | 364 |
| Avoid using redundant field initializer for 'last' | 421 |
| The method 'doAdd' has a Cyclomatic Complexity of 10. | 453–513 |
| Avoid instantiating new objects inside loops | 471 |
| The method doRemove() has an NPath complexity of 2340 | 515–570 |
| The method 'doRemove' has a Modified Cyclomatic Complexity of 13. | 515–570 |
| The method 'doRemove' has a Cyclomatic Complexity of 16. | 515–570 |
| The method 'doRemove' has a Standard Cyclomatic Complexity of 13. | 515–570 |
| The method 'lookupValue' has a Cyclomatic Complexity of 17. | 614–683 |
| The method 'lookupValue' has a Standard Cyclomatic Complexity of 16. | 614–683 |
| The method 'lookupValue' has a Modified Cyclomatic Complexity of 16. | 614–683 |
| The method lookupValue() has an NPath complexity of 1752 | 614–683 |
| Avoid instantiating new objects inside loops | 644 |
| Avoid instantiating new objects inside loops | 646 |
| Avoid instantiating new objects inside loops | 652–653 |
| The method 'cleanZombies' has a Modified Cyclomatic Complexity of 17. | 745–816 |
| The method 'cleanZombies' has a Cyclomatic Complexity of 18. | 745–816 |
| The method 'cleanZombies' has a Standard Cyclomatic Complexity of 17. | 745–816 |
| The method cleanZombies() has an NPath complexity of 3073 | 745–816 |
| A switch with less than three branches is inefficient, use a if statement instead. | 874–879 |
| The class 'ModelLiteral' has a Cyclomatic Complexity of 2 (Highest = 11). | 1130–1314 |
| The method 'equals' has a Cyclomatic Complexity of 11. | 1268–1288 |
| Avoid appending characters as strings in StringBuffer.append. | 1309 |
| Ensure that resources like this Statement object are closed after use | 1439 |
| Avoid appending characters as strings in StringBuffer.append. | 1457 |
| Avoid appending characters as strings in StringBuffer.append. | 1458 |
| Avoid appending characters as strings in StringBuffer.append. | 1460 |
rdfpro-core - eu/fbk/rdfpro/util/QuadModelModelAdapter.java
| Violation | Line |
|---|---|
| Consider using varargs for methods or constructors which take an array the last parameter. | 69 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 76 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 82 |
| Avoid instantiating new objects inside loops | 90 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 98 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 112 |
rdfpro-core - eu/fbk/rdfpro/util/QuadModelRepositoryAdapter.java
| Violation | Line |
|---|---|
| Consider using varargs for methods or constructors which take an array the last parameter. | 109 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 140 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 151 |
| Avoid instantiating new objects inside loops | 171 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 186 |
rdfpro-core - eu/fbk/rdfpro/util/QuadModelSailAdapter.java
| Violation | Line |
|---|---|
| Consider using varargs for methods or constructors which take an array the last parameter. | 133 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 164 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 175 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 210 |
| Avoid reassigning parameters such as 'bindings' | 239 |
rdfpro-core - eu/fbk/rdfpro/util/QuadModelSubModel.java
| Violation | Line |
|---|---|
| Possible God class (WMC=71, ATFD=17, TCC=0.0) | 14–359 |
| The class 'QuadModelSubModel' has a Modified Cyclomatic Complexity of 4 (Highest = 17). | 35–359 |
| The class 'QuadModelSubModel' has a Cyclomatic Complexity of 5 (Highest = 25). | 35–359 |
| The class 'QuadModelSubModel' has a Standard Cyclomatic Complexity of 4 (Highest = 17). | 35–359 |
| Deeply nested if..then statements are hard to read | 62–64 |
| Ensure that resources like this Statement object are closed after use | 95 |
| Deeply nested if..then statements are hard to read | 131–133 |
| The method 'doIterator' has a Cyclomatic Complexity of 25. | 143–237 |
| The method doIterator() has an NPath complexity of 3150 | 143–237 |
| The method 'doIterator' has a Modified Cyclomatic Complexity of 17. | 143–237 |
| The method 'doIterator' has a Standard Cyclomatic Complexity of 17. | 143–237 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 144 |
| Avoid using redundant field initializer for 'offset' | 150 |
| Avoid using redundant field initializer for 'next' | 191 |
| The method 'hasNext' has a Cyclomatic Complexity of 13. | 194–224 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 256 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 268 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 274 |
rdfpro-core - eu/fbk/rdfpro/util/SPARQLRenderer.java
| Violation | Line |
|---|---|
| Possible God class (WMC=370, ATFD=281, TCC=0.0) | 14–1687 |
| Avoid appending characters as strings in StringBuffer.append. | 208 |
| Avoid appending characters as strings in StringBuffer.append. | 258 |
| The class 'Rendering' has a Modified Cyclomatic Complexity of 2 (Highest = 26). | 358–1374 |
| The class 'Rendering' has a Standard Cyclomatic Complexity of 2 (Highest = 26). | 358–1374 |
| The class 'Rendering' has a Cyclomatic Complexity of 2 (Highest = 27). | 358–1374 |
| StringBuffers can grow quite a lot, and so may become a source of memory leak (if the owning class has a long life time). | 369 |
| The method emit() has an NPath complexity of 97200 | 508–584 |
| The method 'emit' has a Cyclomatic Complexity of 27. | 508–584 |
| The method 'emit' has a Modified Cyclomatic Complexity of 26. | 508–584 |
| The method 'emit' has a Standard Cyclomatic Complexity of 26. | 508–584 |
| This call to String.startsWith can be rewritten using String.charAt(0) | 532 |
| This call to String.startsWith can be rewritten using String.charAt(0) | 666 |
| The method 'emitPropertyPath' has a Cyclomatic Complexity of 17. | 916–1002 |
| The method 'emitPropertyPath' has a Standard Cyclomatic Complexity of 16. | 916–1002 |
| The method 'emitPropertyPath' has a Modified Cyclomatic Complexity of 16. | 916–1002 |
| When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 1268 |
| The class 'Query' has a Cyclomatic Complexity of 14 (Highest = 30). | 1384–1685 |
| The class 'Query' has a Modified Cyclomatic Complexity of 10 (Highest = 25). | 1384–1685 |
| The class 'Query' has a Standard Cyclomatic Complexity of 10 (Highest = 25). | 1384–1685 |
| The method 'create' has a Modified Cyclomatic Complexity of 25. | 1416–1535 |
| The method create() has an NPath complexity of 6630 | 1416–1535 |
| The method 'create' has a Standard Cyclomatic Complexity of 25. | 1416–1535 |
| The method 'create' has a Cyclomatic Complexity of 30. | 1416–1535 |
| Avoid really long methods. | 1416–1535 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 1441 |
| Avoid instantiating new objects inside loops | 1477 |
| Avoid instantiating new objects inside loops | 1497 |
| The method 'extractQueryNodes' has a Cyclomatic Complexity of 30. | 1537–1600 |
| The method 'extractQueryNodes' has a Standard Cyclomatic Complexity of 14. | 1537–1600 |
| The method 'extractQueryNodes' has a Modified Cyclomatic Complexity of 14. | 1537–1600 |
| This for loop could be simplified to a while loop | 1580–1582 |
| Avoid instantiating new objects inside loops | 1629–1631 |
| Avoid instantiating new objects inside loops | 1632 |
| Prefer StringBuffer over += for concatenating strings | 1642 |
| Avoid long parameter lists. | 1657–1669 |
rdfpro-core - eu/fbk/rdfpro/util/Scripting.java
| Violation | Line |
|---|---|
| Possible God class (WMC=81, ATFD=28, TCC=0.0) | 14–351 |
| The class 'Scripting' has a Modified Cyclomatic Complexity of 6 (Highest = 12). | 39–351 |
| 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. | 39–351 |
| The class 'Scripting' has a Standard Cyclomatic Complexity of 6 (Highest = 12). | 39–351 |
| The class 'Scripting' has a Cyclomatic Complexity of 8 (Highest = 18). | 39–351 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 57 |
| Deeply nested if..then statements are hard to read | 58–60 |
| Avoid instantiating new objects inside loops | 61 |
| Avoid instantiating new objects inside loops | 62–63 |
| Avoid appending characters as strings in StringBuffer.append. | 66 |
| New exception is thrown in catch block, original stack trace may be lost | 69 |
| The method 'compile' has a Modified Cyclomatic Complexity of 12. | 94–167 |
| The method compile() has an NPath complexity of 2160 | 94–167 |
| The method 'compile' has a Standard Cyclomatic Complexity of 12. | 94–167 |
| The method 'compile' has a Cyclomatic Complexity of 13. | 94–167 |
| Avoid empty catch blocks | 137–139 |
| StringBuffer constructor is initialized with size 16, but has at least 111 characters appended. | 159 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 160 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 160 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 161 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 162 |
| New exception is thrown in catch block, original stack trace may be lost | 164 |
| New exception is thrown in catch block, original stack trace may be lost | 164 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 196 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 197 |
| Avoid appending characters as strings in StringBuffer.append. | 198 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 198 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 199 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 200 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 210 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 211 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 212 |
| Avoid appending characters as strings in StringBuffer.append. | 212 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 213 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 214 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 215 |
| The method 'rewrite' has a Cyclomatic Complexity of 12. | 225–280 |
| The method 'rewrite' has a Modified Cyclomatic Complexity of 10. | 225–280 |
| The method 'rewrite' has a Standard Cyclomatic Complexity of 10. | 225–280 |
| Avoid reassigning parameters such as 'i' | 285 |
| The method 'parseURI' has a Cyclomatic Complexity of 13. | 285–301 |
| Avoid reassigning parameters such as 'i' | 285 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 286 |
| Avoid reassigning parameters such as 'i' | 303 |
| Avoid reassigning parameters such as 'i' | 303 |
| The method parseQName() has an NPath complexity of 1920 | 303–332 |
| The method 'parseQName' has a Cyclomatic Complexity of 18. | 303–332 |
| Avoid reassigning parameters such as 'i' | 303 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 304 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 305 |
rdfpro-core - eu/fbk/rdfpro/util/Sorter.java
| Violation | Line |
|---|---|
| Possible God class (WMC=200, ATFD=21, TCC=0.007112375533428165) | 14–1154 |
| The class 'Sorter' has a Cyclomatic Complexity of 4 (Highest = 14). | 43–1154 |
| The class 'Sorter' has a Modified Cyclomatic Complexity of 4 (Highest = 14). | 43–1154 |
| The class 'Sorter' has a Standard Cyclomatic Complexity of 4 (Highest = 14). | 43–1154 |
| New exception is thrown in catch block, original stack trace may be lost | 177 |
| The method 'end' has a Cyclomatic Complexity of 14. | 184–260 |
| The method 'end' has a Standard Cyclomatic Complexity of 14. | 184–260 |
| The method 'end' has a Modified Cyclomatic Complexity of 14. | 184–260 |
| Avoid instantiating new objects inside loops | 220 |
| Avoid instantiating new objects inside loops | 224–231 |
| The class 'Output' has a Cyclomatic Complexity of 4 (Highest = 16). | 328–490 |
| The class 'Output' has a Modified Cyclomatic Complexity of 4 (Highest = 15). | 328–490 |
| The class 'Output' has a Standard Cyclomatic Complexity of 4 (Highest = 15). | 328–490 |
| Unnecessary final modifier in final class | 350–360 |
| The method 'writeValue' has a Cyclomatic Complexity of 16. | 362–417 |
| The method 'writeValue' has a Standard Cyclomatic Complexity of 15. | 362–417 |
| The method 'writeValue' has a Modified Cyclomatic Complexity of 15. | 362–417 |
| Unnecessary final modifier in final class | 362–417 |
| Unnecessary final modifier in final class | 419–425 |
| The method 'writeNumber' has a Cyclomatic Complexity of 11. | 427–449 |
| The method 'writeNumber' has a Standard Cyclomatic Complexity of 10. | 427–449 |
| Unnecessary final modifier in final class | 427–449 |
| The method 'writeNumber' has a Modified Cyclomatic Complexity of 10. | 427–449 |
| The class 'Input' has a Standard Cyclomatic Complexity of 4 (Highest = 11). | 492–666 |
| The class 'Input' has a Cyclomatic Complexity of 4 (Highest = 12). | 492–666 |
| The class 'Input' has a Modified Cyclomatic Complexity of 4 (Highest = 11). | 492–666 |
| StringBuffers can grow quite a lot, and so may become a source of memory leak (if the owning class has a long life time). | 498 |
| Unnecessary final modifier in final class | 531–533 |
| Unnecessary final modifier in final class | 536–549 |
| Unnecessary final modifier in final class | 552–586 |
| The method 'readValue' has a Cyclomatic Complexity of 12. | 552–586 |
| The method 'readValue' has a Modified Cyclomatic Complexity of 11. | 552–586 |
| The method 'readValue' has a Standard Cyclomatic Complexity of 11. | 552–586 |
| Unnecessary final modifier in final class | 589–597 |
| The method 'readNumber' has a Modified Cyclomatic Complexity of 10. | 599–622 |
| The method 'readNumber' has a Cyclomatic Complexity of 10. | 599–622 |
| The method 'readNumber' has a Standard Cyclomatic Complexity of 10. | 599–622 |
| Unnecessary final modifier in final class | 599–622 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 722 |
| The class 'Dictionary' has a Cyclomatic Complexity of 3 (Highest = 10). | 772–1152 |
| Avoid instantiating new objects inside loops | 828 |
| The method 'encodeURI' has a Cyclomatic Complexity of 10. | 848–897 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 848 |
| StringBuffer constructor is initialized with size 16, but has at least 93 characters appended. | 943 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 944 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 944 |
| Avoid appending characters as strings in StringBuffer.append. | 944 |
| Avoid appending characters as strings in StringBuffer.append. | 945 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 945 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 945 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 946 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 946 |
| Avoid appending characters as strings in StringBuffer.append. | 946 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 947 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 947 |
| Avoid appending characters as strings in StringBuffer.append. | 947 |
| The class 'StringIndex' has a Standard Cyclomatic Complexity of 4 (Highest = 12). | 952–1076 |
| The class 'StringIndex' has a Cyclomatic Complexity of 5 (Highest = 15). | 952–1076 |
| The class 'StringIndex' has a Modified Cyclomatic Complexity of 4 (Highest = 12). | 952–1076 |
| Avoid instantiating new objects inside loops | 973 |
| The method 'put' has a Cyclomatic Complexity of 15. | 978–1043 |
| The method 'put' has a Modified Cyclomatic Complexity of 12. | 978–1043 |
| The method 'put' has a Standard Cyclomatic Complexity of 12. | 978–1043 |
| The class 'GenericIndex' has a Cyclomatic Complexity of 4 (Highest = 10). | 1078–1150 |
| The method 'put' has a Cyclomatic Complexity of 10. | 1093–1134 |
rdfpro-core - eu/fbk/rdfpro/util/Sorting.java
| Violation | Line |
|---|---|
| Consider using varargs for methods or constructors which take an array the last parameter. | 25 |
| The user-supplied array 'data' is stored directly. | 58 |
rdfpro-core - eu/fbk/rdfpro/util/StatementComponent.java
| Violation | Line |
|---|---|
| Avoid reassigning parameters such as 'letter' | 162 |
rdfpro-core - eu/fbk/rdfpro/util/StatementDeduplicator.java
| Violation | Line |
|---|---|
| Possible God class (WMC=100, ATFD=41, TCC=0.0) | 14–588 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 135 |
| Avoid instantiating new objects inside loops | 172 |
| Use block level rather than method level synchronization | 204–231 |
| The class 'TotalEqualsDeduplicator' has a Cyclomatic Complexity of 6 (Highest = 16). | 255–320 |
| The class 'TotalEqualsDeduplicator' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 255–320 |
| The class 'TotalEqualsDeduplicator' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 255–320 |
| The method 'process' has a Standard Cyclomatic Complexity of 10. | 274–318 |
| The method process() has an NPath complexity of 625 | 274–318 |
| The method 'process' has a Cyclomatic Complexity of 16. | 274–318 |
| The method 'process' has a Modified Cyclomatic Complexity of 10. | 274–318 |
| The class 'TotalIdentityDeduplicator' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 322–388 |
| The class 'TotalIdentityDeduplicator' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 322–388 |
| The class 'TotalIdentityDeduplicator' has a Cyclomatic Complexity of 5 (Highest = 13). | 322–388 |
| The method 'process' has a Cyclomatic Complexity of 13. | 341–386 |
| The method 'process' has a Standard Cyclomatic Complexity of 10. | 341–386 |
| The method 'process' has a Modified Cyclomatic Complexity of 10. | 341–386 |
| The method process() has an NPath complexity of 475 | 341–386 |
| Avoid instantiating new objects inside loops | 400 |
| Avoid instantiating new objects inside loops | 449 |
| The method process() has an NPath complexity of 300 | 459–488 |
| The class 'PartialEqualsDeduplicator' has a Cyclomatic Complexity of 5 (Highest = 12). | 492–547 |
| Avoid instantiating new objects inside loops | 506 |
| The method 'process' has a Cyclomatic Complexity of 12. | 516–545 |
| The method process() has an NPath complexity of 450 | 516–545 |
| The user-supplied array 'deduplicators' is stored directly. | 555 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 555 |
rdfpro-core - eu/fbk/rdfpro/util/StatementMatcher.java
| Violation | Line |
|---|---|
| Possible God class (WMC=135, ATFD=48, TCC=0.019762845849802372) | 14–690 |
| The class 'StatementMatcher' has a Standard Cyclomatic Complexity of 4 (Highest = 14). | 52–690 |
| The class 'StatementMatcher' has a Cyclomatic Complexity of 4 (Highest = 15). | 52–690 |
| The class 'StatementMatcher' has a Modified Cyclomatic Complexity of 4 (Highest = 14). | 52–690 |
| The user-supplied array 'masks' is stored directly. | 80 |
| The user-supplied array 'values' is stored directly. | 80 |
| The user-supplied array 'tables' is stored directly. | 80 |
| The method match() has an NPath complexity of 240 | 108–158 |
| The method 'match' has a Cyclomatic Complexity of 15. | 108–158 |
| The method 'match' has a Modified Cyclomatic Complexity of 14. | 108–158 |
| The method 'match' has a Standard Cyclomatic Complexity of 14. | 108–158 |
| Avoid reassigning parameters such as 'ctx' | 109 |
| Deeply nested if..then statements are hard to read | 138–140 |
| Avoid instantiating new objects inside loops | 139 |
| The method 'map' has a Cyclomatic Complexity of 15. | 166–214 |
| The method map() has an NPath complexity of 670 | 166–214 |
| The method 'map' has a Standard Cyclomatic Complexity of 13. | 166–214 |
| The method 'map' has a Modified Cyclomatic Complexity of 13. | 166–214 |
| Avoid reassigning parameters such as 'ctx' | 167 |
| Avoid instantiating new objects inside loops | 207 |
| The method 'match' has a Cyclomatic Complexity of 10. | 221–250 |
| The method 'normalizeIfNecessary' has a Cyclomatic Complexity of 10. | 252–271 |
| The class 'Builder' has a Modified Cyclomatic Complexity of 5 (Highest = 13). | 349–553 |
| The class 'Builder' has a Cyclomatic Complexity of 5 (Highest = 14). | 349–553 |
| The class 'Builder' has a Standard Cyclomatic Complexity of 5 (Highest = 13). | 349–553 |
| Avoid instantiating new objects inside loops | 386 |
| Avoid reassigning parameters such as 'filter' | 397 |
| The method build() has an NPath complexity of 549 | 458–551 |
| The method 'build' has a Cyclomatic Complexity of 14. | 458–551 |
| The method 'build' has a Modified Cyclomatic Complexity of 13. | 458–551 |
| The method 'build' has a Standard Cyclomatic Complexity of 13. | 458–551 |
| Avoid instantiating new objects inside loops | 497 |
| Avoid instantiation through private constructors from outside of the constructors class. | 549–550 |
rdfpro-core - eu/fbk/rdfpro/util/StatementTemplate.java
| Violation | Line |
|---|---|
| Possible God class (WMC=60, ATFD=40, TCC=0.0) | 14–241 |
| The class 'StatementTemplate' has a Cyclomatic Complexity of 4 (Highest = 12). | 31–241 |
| The method normalize() has an NPath complexity of 5000 | 78–90 |
| Avoid empty catch blocks | 114–115 |
| The method 'componentFor' has a Cyclomatic Complexity of 12. | 217–240 |
rdfpro-core - eu/fbk/rdfpro/util/Statements.java
| Violation | Line |
|---|---|
| Possible God class (WMC=475, ATFD=258, TCC=8.163265306122449E-4) | 14–1573 |
| The class 'Statements' has a Standard Cyclomatic Complexity of 6 (Highest = 29). | 56–1573 |
| The class 'Statements' has a Modified Cyclomatic Complexity of 5 (Highest = 29). | 56–1573 |
| The class 'Statements' has a Cyclomatic Complexity of 8 (Highest = 52). | 56–1573 |
| The method 'isRDFFormatTextBased' has a Cyclomatic Complexity of 12. | 260–271 |
| Position literals first in String comparisons for EqualsIgnoreCase | 262 |
| Position literals first in String comparisons for EqualsIgnoreCase | 262 |
| Position literals first in String comparisons for EqualsIgnoreCase | 263 |
| Position literals first in String comparisons for EqualsIgnoreCase | 263 |
| Position literals first in String comparisons for EqualsIgnoreCase | 264 |
| Position literals first in String comparisons for EqualsIgnoreCase | 264 |
| Position literals first in String comparisons for EqualsIgnoreCase | 265 |
| Position literals first in String comparisons for EqualsIgnoreCase | 265 |
| Position literals first in String comparisons for EqualsIgnoreCase | 266 |
| Position literals first in String comparisons for EqualsIgnoreCase | 266 |
| Position literals first in String comparisons for EqualsIgnoreCase | 275 |
| Position literals first in String comparisons for EqualsIgnoreCase | 275 |
| Position literals first in String comparisons for EqualsIgnoreCase | 276 |
| The method 'isGoodQName' has a Cyclomatic Complexity of 18. | 343–371 |
| The method 'formatURI' has a Standard Cyclomatic Complexity of 16. | 373–435 |
| The method 'formatURI' has a Cyclomatic Complexity of 16. | 373–435 |
| A switch statement does not contain a break | 394–432 |
| The method 'formatLiteral' has a Modified Cyclomatic Complexity of 11. | 469–554 |
| The method 'formatLiteral' has a Standard Cyclomatic Complexity of 18. | 469–554 |
| The method 'formatLiteral' has a Cyclomatic Complexity of 20. | 469–554 |
| A switch statement does not contain a break | 476–516 |
| The method 'parseURI' has a Cyclomatic Complexity of 52. | 576–663 |
| The method parseURI() has an NPath complexity of 679 | 576–663 |
| The method 'parseURI' has a Standard Cyclomatic Complexity of 20. | 576–663 |
| The method 'parseURI' has a Modified Cyclomatic Complexity of 20. | 576–663 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 580 |
| The method 'parseLiteral' has a Cyclomatic Complexity of 26. | 688–757 |
| The method 'parseLiteral' has a Standard Cyclomatic Complexity of 15. | 688–757 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 760 |
| The method 'convertObject' has a Cyclomatic Complexity of 15. | 920–955 |
| The method 'convertObject' has a Standard Cyclomatic Complexity of 15. | 920–955 |
| The method 'convertObject' has a Modified Cyclomatic Complexity of 15. | 920–955 |
| The method 'convertLiteral' has a Standard Cyclomatic Complexity of 14. | 966–1001 |
| The method 'convertLiteral' has a Cyclomatic Complexity of 24. | 966–1001 |
| The method 'convertLiteral' has a Modified Cyclomatic Complexity of 14. | 966–1001 |
| The method 'convertString' has a Cyclomatic Complexity of 37. | 1016–1071 |
| The method 'convertString' has a Standard Cyclomatic Complexity of 29. | 1016–1071 |
| The method 'convertString' has a Modified Cyclomatic Complexity of 29. | 1016–1071 |
| The method 'convertNumber' has a Modified Cyclomatic Complexity of 21. | 1074–1117 |
| The method 'convertNumber' has a Standard Cyclomatic Complexity of 21. | 1074–1117 |
| The method 'convertNumber' has a Cyclomatic Complexity of 29. | 1074–1117 |
| Avoid creating BigDecimal with a decimal (float/double) literal. Use a String literal | 1191 |
| The class 'ValueComparator' has a Modified Cyclomatic Complexity of 6 (Highest = 12). | 1226–1285 |
| The class 'ValueComparator' has a Standard Cyclomatic Complexity of 6 (Highest = 12). | 1226–1285 |
| The class 'ValueComparator' has a Cyclomatic Complexity of 7 (Highest = 16). | 1226–1285 |
| The method 'compare' has a Standard Cyclomatic Complexity of 12. | 1235–1274 |
| The method 'compare' has a Modified Cyclomatic Complexity of 12. | 1235–1274 |
| The method 'compare' has a Cyclomatic Complexity of 16. | 1235–1274 |
| The class 'StatementMatcher' has a Standard Cyclomatic Complexity of 10 (Highest = 17). | 1336–1571 |
| The class 'StatementMatcher' has a Cyclomatic Complexity of 10 (Highest = 19). | 1336–1571 |
| The class 'StatementMatcher' has a Modified Cyclomatic Complexity of 10 (Highest = 17). | 1336–1571 |
| The constructor 'StatementMatcher' has a Cyclomatic Complexity of 19. | 1351–1409 |
| The constructor 'StatementMatcher' has a Modified Cyclomatic Complexity of 17. | 1351–1409 |
| The constructor 'StatementMatcher' has a Standard Cyclomatic Complexity of 17. | 1351–1409 |
| Avoid instantiating new objects inside loops | 1357 |
| Avoid instantiating new objects inside loops | 1402–1403 |
| The class 'ValueMatcher' has a Modified Cyclomatic Complexity of 5 (Highest = 15). | 1419–1569 |
| The class 'ValueMatcher' has a Cyclomatic Complexity of 5 (Highest = 15). | 1419–1569 |
| The class 'ValueMatcher' has a Standard Cyclomatic Complexity of 5 (Highest = 15). | 1419–1569 |
| The constructor 'ValueMatcher' has a Modified Cyclomatic Complexity of 15. | 1453–1517 |
| The constructor 'ValueMatcher' has a Cyclomatic Complexity of 15. | 1453–1517 |
| The constructor 'ValueMatcher' has a Standard Cyclomatic Complexity of 15. | 1453–1517 |
rdfpro-core - eu/fbk/rdfpro/util/StringIndex.java
| Violation | Line |
|---|---|
| Useless parentheses. | 272 |
rdfpro-core - eu/fbk/rdfpro/util/Tracker.java
| Violation | Line |
|---|---|
| Avoid using redundant field initializer for 'counterAtTs' | 52 |
| Use block level rather than method level synchronization | 113–137 |
rdfpro-dist - eu/fbk/rdfpro/tool/GeonamesRDF.java
| Violation | Line |
|---|---|
| Document empty method body | 82–83 |
| Document empty method body | 86–87 |
| Avoid instantiating new objects inside loops | 96–97 |
| Avoid instantiating new objects inside loops | 121 |
rdfpro-dist - eu/fbk/rdfpro/tool/Logging.java
| Violation | Line |
|---|---|
| Possible God class (WMC=51, ATFD=22, TCC=0.01818181818181818) | 14–335 |
| 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. | 34–335 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 47 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 48 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 49 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 50 |
| Unnecessary use of fully qualified name 'ch.qos.logback.classic.Level.ERROR_INT' due to existing import 'ch.qos.logback.classic.Level' | 67 |
| Unnecessary use of fully qualified name 'ch.qos.logback.classic.Level.WARN_INT' due to existing import 'ch.qos.logback.classic.Level' | 69 |
| Unnecessary use of fully qualified name 'ch.qos.logback.classic.Level.ERROR_INT' due to existing import 'ch.qos.logback.classic.Level' | 84 |
| Unnecessary use of fully qualified name 'ch.qos.logback.classic.Level.WARN_INT' due to existing import 'ch.qos.logback.classic.Level' | 86 |
| Use block level rather than method level synchronization | 103–105 |
| Use block level rather than method level synchronization | 107–113 |
| Use block level rather than method level synchronization | 116–149 |
| Use block level rather than method level synchronization | 152–166 |
| Use block level rather than method level synchronization | 169–183 |
| Use block level rather than method level synchronization | 200–204 |
| Use block level rather than method level synchronization | 207–211 |
| Use block level rather than method level synchronization | 214–219 |
| Use block level rather than method level synchronization | 221–226 |
| The user-supplied array 'status' is stored directly. | 221 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 270 |
| An instanceof check is being performed on the caught exception. Create a separate catch clause for this exception type. | 272 |
rdfpro-dist - eu/fbk/rdfpro/tool/Main.java
| Violation | Line |
|---|---|
| The class 'Main' has a Standard Cyclomatic Complexity of 6 (Highest = 14). | 49–211 |
| The class 'Main' has a Modified Cyclomatic Complexity of 6 (Highest = 14). | 49–211 |
| 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. | 49–211 |
| The class 'Main' has a Cyclomatic Complexity of 6 (Highest = 16). | 49–211 |
| The method main() has an NPath complexity of 3328 | 59–149 |
| The method 'main' has a Modified Cyclomatic Complexity of 14. | 59–149 |
| The method 'main' has a Standard Cyclomatic Complexity of 14. | 59–149 |
| The method 'main' has a Cyclomatic Complexity of 16. | 59–149 |
| Avoid empty catch blocks | 63–65 |
| Avoid empty catch blocks | 69–71 |
| This call to String.startsWith can be rewritten using String.charAt(0) | 80 |
| This call to String.startsWith can be rewritten using String.charAt(0) | 80 |
| This call to String.startsWith can be rewritten using String.charAt(0) | 80 |
| Position literals first in String comparisons | 83 |
| Position literals first in String comparisons | 84 |
| Position literals first in String comparisons | 85 |
| Position literals first in String comparisons | 87 |
| Avoid empty catch blocks | 101–103 |
| Avoid appending characters as strings in StringBuffer.append. | 185 |
| New exception is thrown in catch block, original stack trace may be lost | 192 |
rdfpro-dist - org/openrdf/query/algebra/evaluation/QueryBindingSet.java
| Violation | Line |
|---|---|
| Possible God class (WMC=91, ATFD=14, TCC=0.023715415019762844) | 14–416 |
| The class 'QueryBindingSet' has a Modified Cyclomatic Complexity of 3 (Highest = 16). | 39–416 |
| The class 'QueryBindingSet' has a Cyclomatic Complexity of 4 (Highest = 17). | 39–416 |
| The class 'QueryBindingSet' has a Standard Cyclomatic Complexity of 3 (Highest = 16). | 39–416 |
| The method 'equals' has a Cyclomatic Complexity of 17. | 230–278 |
| The method equals() has an NPath complexity of 624 | 230–278 |
| The method 'equals' has a Modified Cyclomatic Complexity of 16. | 230–278 |
| The method 'equals' has a Standard Cyclomatic Complexity of 16. | 230–278 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 351 |
| The user-supplied array 'data' is stored directly. | 351 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 392 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 405 |
rdfpro-groovy - eu/fbk/rdfpro/GroovyProcessor.java
| Violation | Line |
|---|---|
| Possible God class (WMC=274, ATFD=75, TCC=7.541478129713424E-4) | 14–1257 |
| The class 'GroovyProcessor' has a Standard Cyclomatic Complexity of 4 (Highest = 14). | 77–1257 |
| The class 'GroovyProcessor' has a Modified Cyclomatic Complexity of 4 (Highest = 14). | 77–1257 |
| The class 'GroovyProcessor' has a Cyclomatic Complexity of 4 (Highest = 14). | 77–1257 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 212 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 216 |
| StringBuffer (or StringBuilder).append is called 2 consecutive times with literal Strings. Use a single append with a single combined String. | 220 |
| The class 'Loader' has a Standard Cyclomatic Complexity of 8 (Highest = 11). | 227–516 |
| The class 'Loader' has a Cyclomatic Complexity of 12 (Highest = 18). | 227–516 |
| The class 'Loader' has a Modified Cyclomatic Complexity of 8 (Highest = 11). | 227–516 |
| Avoid instantiating new objects inside loops | 243 |
| Avoid instantiating new objects inside loops | 245 |
| The method 'getResourceConnection' has a Modified Cyclomatic Complexity of 10. | 256–296 |
| The method 'getResourceConnection' has a Standard Cyclomatic Complexity of 10. | 256–296 |
| The method 'getResourceConnection' has a Cyclomatic Complexity of 10. | 256–296 |
| Avoid instantiating new objects inside loops | 264 |
| Avoid instantiating new objects inside loops | 267 |
| Avoid instantiating new objects inside loops | 277 |
| Avoid instantiating new objects inside loops | 278 |
| Avoid instantiating new objects inside loops | 283 |
| Avoid instantiating new objects inside loops | 284 |
| The method 'filter' has a Cyclomatic Complexity of 13. | 298–357 |
| The method 'filter' has a Standard Cyclomatic Complexity of 11. | 298–357 |
| The method 'filter' has a Modified Cyclomatic Complexity of 11. | 298–357 |
| The method 'parseURI' has a Cyclomatic Complexity of 13. | 359–379 |
| Avoid reassigning parameters such as 'i' | 359 |
| Avoid reassigning parameters such as 'i' | 359 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 361 |
| The method 'parseQName' has a Cyclomatic Complexity of 18. | 381–418 |
| Avoid reassigning parameters such as 'i' | 381 |
| Avoid reassigning parameters such as 'i' | 381 |
| Avoid reassigning parameters such as 'i' | 381 |
| The method parseQName() has an NPath complexity of 1920 | 381–418 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 383 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 384 |
| Avoid appending characters as strings in StringBuffer.append. | 466 |
| Private field 'allScripts' could be made final; it is only initialized in the declaration or constructor. | 520 |
| Private field 'threadScript' could be made final; it is only initialized in the declaration or constructor. | 522 |
| Use block level rather than method level synchronization | 591–594 |
| Use block level rather than method level synchronization | 597–600 |
| Use block level rather than method level synchronization | 603–606 |
| The class 'HandlerScript' has a Standard Cyclomatic Complexity of 4 (Highest = 20). | 610–948 |
| The class 'HandlerScript' has a Modified Cyclomatic Complexity of 4 (Highest = 20). | 610–948 |
| The class 'HandlerScript' has a Cyclomatic Complexity of 5 (Highest = 21). | 610–948 |
| The method 'getProperty' has a Standard Cyclomatic Complexity of 14. | 636–663 |
| The method 'getProperty' has a Modified Cyclomatic Complexity of 14. | 636–663 |
| The method 'getProperty' has a Cyclomatic Complexity of 15. | 636–663 |
| The method 'setProperty' has a Modified Cyclomatic Complexity of 20. | 666–716 |
| The method 'setProperty' has a Standard Cyclomatic Complexity of 20. | 666–716 |
| The method 'setProperty' has a Cyclomatic Complexity of 21. | 666–716 |
| The method setProperty() has an NPath complexity of 14762 | 666–716 |
| Prefer StringBuffer over += for concatenating strings | 703 |
| Prefer StringBuffer over += for concatenating strings | 703 |
| Prefer StringBuffer over += for concatenating strings | 704 |
| Prefer StringBuffer over += for concatenating strings | 704 |
| Consider using varargs for methods or constructors which take an array the last parameter. | 718 |
| The method 'createHashSet' has a Standard Cyclomatic Complexity of 11. | 896–946 |
| The method 'createHashSet' has a Modified Cyclomatic Complexity of 11. | 896–946 |
| The method 'createHashSet' has a Cyclomatic Complexity of 11. | 896–946 |
| Document empty method body | 906–907 |
| Document empty method body | 910–911 |
| Document empty method body | 915–916 |
| Document empty method body | 935–936 |
| The method 'toRDF' has a Cyclomatic Complexity of 14. | 951–990 |
| The method 'toRDF' has a Standard Cyclomatic Complexity of 14. | 951–990 |
| The method 'toRDF' has a Modified Cyclomatic Complexity of 14. | 951–990 |
| Avoid unused private methods such as 'toLiteral(Object,String)'. | 993 |
| Ensure that resources like this Statement object are closed after use | 1100 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 1115 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 1116 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 1117 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 1118 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 1119 |
| Avoid appending characters as strings in StringBuffer.append. | 1124 |
| The class 'GroovyLiteral' has a Modified Cyclomatic Complexity of 4 (Highest = 11). | 1170–1211 |
| The class 'GroovyLiteral' has a Cyclomatic Complexity of 4 (Highest = 11). | 1170–1211 |
| The class 'GroovyLiteral' has a Standard Cyclomatic Complexity of 4 (Highest = 11). | 1170–1211 |
| The method 'compareTo' has a Modified Cyclomatic Complexity of 11. | 1187–1209 |
| The method 'compareTo' has a Standard Cyclomatic Complexity of 11. | 1187–1209 |
| The method 'compareTo' has a Cyclomatic Complexity of 11. | 1187–1209 |
| The class 'ValueSet' has a Cyclomatic Complexity of 5 (Highest = 10). | 1213–1255 |
| The method 'match' has a Cyclomatic Complexity of 10. | 1229–1253 |
| These nested if statements could be combined | 1232–1234 |
| These nested if statements could be combined | 1237–1239 |
| These nested if statements could be combined | 1242–1244 |
rdfpro-groovy - eu/fbk/rdfpro/SparqlFunctions.java
| Violation | Line |
|---|---|
| Possible God class (WMC=100, ATFD=31, TCC=0.0) | 14–467 |
| 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. | 83–467 |
| The class 'SparqlFunctions' has a Cyclomatic Complexity of 2 (Highest = 13). | 83–467 |
| The class 'SparqlFunctions' has a Standard Cyclomatic Complexity of 2 (Highest = 13). | 83–467 |
| The class 'SparqlFunctions' has a Modified Cyclomatic Complexity of 2 (Highest = 13). | 83–467 |
| Position literals first in String comparisons | 244 |
| The method 'regex' has a Cyclomatic Complexity of 12. | 264–309 |
| The method 'regex' has a Standard Cyclomatic Complexity of 10. | 264–309 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 275 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 276 |
| The method 'toRDF' has a Modified Cyclomatic Complexity of 13. | 432–465 |
| The method 'toRDF' has a Standard Cyclomatic Complexity of 13. | 432–465 |
| The method 'toRDF' has a Cyclomatic Complexity of 13. | 432–465 |
rdfpro-jsonld - eu/fbk/rdfpro/jsonld/JSONLDParser.java
| Violation | Line |
|---|---|
| Document empty method body | 116–117 |
| The method emit() has an NPath complexity of 480 | 177–211 |
rdfpro-jsonld - eu/fbk/rdfpro/jsonld/JSONLDWriter.java
| Violation | Line |
|---|---|
| Possible God class (WMC=94, ATFD=43, TCC=0.0) | 14–532 |
| The class 'JSONLDWriter' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 59–532 |
| The class 'JSONLDWriter' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 59–532 |
| The class 'JSONLDWriter' has a Cyclomatic Complexity of 4 (Highest = 16). | 59–532 |
| The method flush() has an NPath complexity of 270 | 190–255 |
| The method 'flush' has a Modified Cyclomatic Complexity of 10. | 190–255 |
| The method 'flush' has a Cyclomatic Complexity of 16. | 190–255 |
| The method 'flush' has a Standard Cyclomatic Complexity of 10. | 190–255 |
| Ensure that resources like this Statement object are closed after use | 300 |
| The method 'emitString' has a Cyclomatic Complexity of 10. | 375–399 |
| The class 'StatementComparator' has a Standard Cyclomatic Complexity of 11 (Highest = 19). | 465–530 |
| The class 'StatementComparator' has a Cyclomatic Complexity of 11 (Highest = 19). | 465–530 |
| The class 'StatementComparator' has a Modified Cyclomatic Complexity of 11 (Highest = 19). | 465–530 |
| The method 'compare' has a Modified Cyclomatic Complexity of 19. | 478–529 |
| The method 'compare' has a Standard Cyclomatic Complexity of 19. | 478–529 |
| The method 'compare' has a Cyclomatic Complexity of 19. | 478–529 |
rdfpro-tql - eu/fbk/rdfpro/tql/TQL.java
| Violation | Line |
|---|---|
| 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. | 30–77 |
rdfpro-tql - eu/fbk/rdfpro/tql/TQLParser.java
| Violation | Line |
|---|---|
| The class 'TQLParser' has a Standard Cyclomatic Complexity of 5 (Highest = 22). | 40–452 |
| The class 'TQLParser' has a Modified Cyclomatic Complexity of 5 (Highest = 16). | 40–452 |
| The class 'TQLParser' has a Cyclomatic Complexity of 6 (Highest = 26). | 40–452 |
| StringBuffers can grow quite a lot, and so may become a source of memory leak (if the owning class has a long life time). | 48 |
| The method 'parseQuad' has a Standard Cyclomatic Complexity of 14. | 154–225 |
| The method 'parseQuad' has a Cyclomatic Complexity of 18. | 154–225 |
| The method 'parseQuad' has a Modified Cyclomatic Complexity of 14. | 154–225 |
| The method parseQuad() has an NPath complexity of 5122 | 154–225 |
| Ensure that resources like this Statement object are closed after use | 204 |
| Do not add empty strings | 238 |
| The method 'parseBNode' has a Cyclomatic Complexity of 10. | 294–325 |
| The method 'parseLiteral' has a Modified Cyclomatic Complexity of 16. | 327–412 |
| The method parseLiteral() has an NPath complexity of 864 | 327–412 |
| The method 'parseLiteral' has a Standard Cyclomatic Complexity of 22. | 327–412 |
| The method 'parseLiteral' has a Cyclomatic Complexity of 26. | 327–412 |
rdfpro-tql - eu/fbk/rdfpro/tql/TQLWriter.java
| Violation | Line |
|---|---|
| Possible God class (WMC=62, ATFD=18, TCC=0.0) | 14–310 |
| The class 'TQLWriter' has a Cyclomatic Complexity of 5 (Highest = 20). | 38–310 |
| The class 'TQLWriter' has a Standard Cyclomatic Complexity of 5 (Highest = 19). | 38–310 |
| The class 'TQLWriter' has a Modified Cyclomatic Complexity of 3 (Highest = 12). | 38–310 |
| The method 'emitURI' has a Standard Cyclomatic Complexity of 13. | 135–183 |
| The method 'emitURI' has a Cyclomatic Complexity of 13. | 135–183 |
| A switch statement does not contain a break | 141–180 |
| The method 'emitLiteral' has a Cyclomatic Complexity of 20. | 220–308 |
| The method 'emitLiteral' has a Modified Cyclomatic Complexity of 12. | 220–308 |
| The method emitLiteral() has an NPath complexity of 231 | 220–308 |
| The method 'emitLiteral' has a Standard Cyclomatic Complexity of 19. | 220–308 |
| A switch statement does not contain a break | 226–266 |
