Showing 3,691 of 4,645 total issues
Method getEntity
has a Cognitive Complexity of 90 (exceeds 5 allowed). Consider refactoring. Open
public Object getEntity(ByteBuffer buffer, BitEntity entry, SimpleKeyValueList<String, Object> values) {
if (entry == null) {
return null;
}
if (entry.size() < 1) {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method calculateFields
has a Cognitive Complexity of 90 (exceeds 5 allowed). Consider refactoring. Open
public Double[] calculateFields(String formular) {
CharacterBuffer tokener = new CharacterBuffer();
tokener.with(formular);
ArrayList<String> parts = new ArrayList<String>();
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
File RabbitMessage.java
has 766 lines of code (exceeds 250 allowed). Consider refactoring. Open
package de.uniks.networkparser.ext.io;
/*
The MIT License
File GraphTest.java
has 758 lines of code (exceeds 250 allowed). Consider refactoring. Open
package de.uniks.networkparser.test;
import static org.junit.Assert.assertEquals;
import java.io.BufferedWriter;
import java.io.File;
Space
has 92 methods (exceeds 20 allowed). Consider refactoring. Open
public class Space extends SendableItem implements ObjectCondition, SendableEntityCreator {
private final String[] properties = new String[] { Space.PROPERTY_NAME, Space.PROPERTY_PATH, Space.PROPERTY_HISTORY,
Space.PROPERTY_PROXY };
public static final String PROPERTY_MODELROOT = "root";
public static final String PROPERTY_HISTORY = "history";
Function ./layouts/DagreLayoutMin.ts
has 350 lines of code (exceeds 25 allowed). Consider refactoring. Open
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
Method addI18N
has a Cognitive Complexity of 87 (exceeds 5 allowed). Consider refactoring. Open
private boolean addI18N(Object root, TextItems i18n, SimpleSet<Object> items, String key, List<?> subElements) {
if (items == null || i18n == null || items.add(root) == false) {
return false;
}
SendableEntityCreator creator = this.getCreatorClass(root);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
File JsonTest.java
has 746 lines of code (exceeds 250 allowed). Consider refactoring. Open
package de.uniks.networkparser.test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
Method compareEntity
has a Cognitive Complexity of 85 (exceeds 5 allowed). Consider refactoring. Open
public static final boolean compareEntity(Object entityA, Object entityB, TextDiff diffList, BaseItem sameObject) {
if (sameObject == null) {
if (entityA instanceof Entity) {
sameObject = ((BaseItem) entityA).getNewList(true);
} else if (entityB instanceof Entity) {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function ./PropertiesPanel.ts
has a Cognitive Complexity of 85 (exceeds 5 allowed). Consider refactoring. Open
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function ./handlers/ImportFile.ts
has a Cognitive Complexity of 84 (exceeds 5 allowed). Consider refactoring. Open
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function ./elements/nodes/InfoText.ts
has a Cognitive Complexity of 84 (exceeds 5 allowed). Consider refactoring. Open
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
IdMap
has 88 methods (exceeds 20 allowed). Consider refactoring. Open
public class IdMap implements BaseItem, Iterable<SendableEntityCreator>, SendableEntityCreator {
/** The Constant VALUE. */
public static final String VALUE = "value";
/** The Constant ID. */
Function Bridge
has 332 lines of code (exceeds 25 allowed). Consider refactoring. Open
var Bridge = (function (_super) {
__extends(Bridge, _super);
function Bridge(viewRoot) {
var _this = _super.call(this) || this;
_this.controlFactory = {};
Method setValueItem
has a Cognitive Complexity of 83 (exceeds 5 allowed). Consider refactoring. Open
@SuppressWarnings("unchecked")
public SimpleKeyValueList<K, V> setValueItem(Object key, Object value) {
int pos = indexOf(key);
if (pos >= 0) {
this.setValue(pos, (V) value);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function ./PropertiesPanel.ts
has 330 lines of code (exceeds 25 allowed). Consider refactoring. Open
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
Method getCloneByEntity
has a Cognitive Complexity of 82 (exceeds 5 allowed). Consider refactoring. Open
private Object getCloneByEntity(Object reference, MapEntity map) {
if (map == null || map.contains(reference)) {
return null;
}
SendableEntityCreator creator = getCreatorClass(reference);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method parseSheet
has a Cognitive Complexity of 82 (exceeds 5 allowed). Consider refactoring. Open
public ExcelSheet parseSheet(CharSequence stringFile, CharSequence sheetFile) {
ExcelSheet data = new ExcelSheet();
SimpleKeyValueList<String, ExcelCell> cells = new SimpleKeyValueList<String, ExcelCell>();
SimpleKeyValueList<String, String> mergeCellPos = new SimpleKeyValueList<String, String>();
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method diffModel
has a Cognitive Complexity of 82 (exceeds 5 allowed). Consider refactoring. Open
public GraphPatternMatch diffModel(Object master, Object slave, MapEntity map) {
if (map == null || map.add(master) == false) {
return null;
}
GraphPatternMatch result = new GraphPatternMatch();
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
File NodeProxyTCP.java
has 706 lines of code (exceeds 250 allowed). Consider refactoring. Open
package de.uniks.networkparser.ext.petaf.proxy;
/*
The MIT License