fujaba/NetworkParser

View on GitHub

Showing 4,645 of 4,645 total issues

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>();

Severity: Minor
Found in src/main/java/de/uniks/networkparser/parser/ExcelParser.java - About 1 day to fix

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();
Severity: Minor
Found in src/main/java/de/uniks/networkparser/graph/GraphTokener.java - About 1 day to fix

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

    Method calling has a Cognitive Complexity of 81 (exceeds 5 allowed). Consider refactoring.
    Open

        public static Object calling(Object item, String methodName, boolean notify, Object notifyObject,
                Object... arguments) {
            if (methodName == null || item == null) {
                return null;
            }

    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 GraphMatcher.java has 700 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    package de.uniks.networkparser.parser;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    Severity: Major
    Found in src/main/java/de/uniks/networkparser/parser/GraphMatcher.java - About 1 day to fix

      Method unmaskBitMatrix has a Cognitive Complexity of 80 (exceeds 5 allowed). Consider refactoring.
      Open

          final void unmaskBitMatrix(byte mask, BitMatrix bits, int dimension) {
              if (mask == 0) { /* 000: mask bits for which (x + y) mod 2 == 0 */
                  for (int i = 0; i < dimension; i++) {
                      for (int j = 0; j < dimension; j++) {
                          if (((i + j) & 0x01) == 0) {
      Severity: Minor
      Found in src/main/java/de/uniks/networkparser/bytes/qr/BitMatrixParser.java - About 1 day to fix

      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 parsing has a Cognitive Complexity of 79 (exceeds 5 allowed). Consider refactoring.
      Open

          public boolean parsing(GraphModel model, SimpleSet<?> lists) {
              if (lists == null) {
                  return true;
              }
              /* Simple Reverse Engineering */

      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 ./Control.ts has 314 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      /***/ (function(module, exports, __webpack_require__) {
      
      "use strict";
      
      Object.defineProperty(exports, "__esModule", { value: true });
      Severity: Major
      Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

        File Template.java has 687 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        package de.uniks.networkparser.parser;
        
        /*
        The MIT License
        
        
        Severity: Major
        Found in src/main/java/de/uniks/networkparser/parser/Template.java - About 1 day to fix

          Method decodeValue has a Cognitive Complexity of 78 (exceeds 5 allowed). Consider refactoring.
          Open

              public Object decodeValue(byte type, Buffer buffer, int end, MapEntity map) {
                  if (buffer == null || buffer.remaining() < 1) {
                      return null;
                  }
                  if (type == ByteTokener.DATATYPE_NULL) {
          Severity: Minor
          Found in src/main/java/de/uniks/networkparser/bytes/ByteTokener.java - About 1 day to fix

          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 Control has 310 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          var Control = (function () {
              function Control() {
                  this.$viewData = null;
                  this.$viewData = this.initViewDataProperties(this.$viewData);
              }
          Severity: Major
          Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

            Function ./elements/nodes/HTML.ts has a Cognitive Complexity of 76 (exceeds 5 allowed). Consider refactoring.
            Open

            /***/ (function(module, exports, __webpack_require__) {
            
            "use strict";
            
            var __extends = (this && this.__extends) || (function () {
            Severity: Minor
            Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

            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/AutoComplete.ts has a Cognitive Complexity of 75 (exceeds 5 allowed). Consider refactoring.
            Open

            /***/ (function(module, exports, __webpack_require__) {
            
            "use strict";
            
            var __extends = (this && this.__extends) || (function () {
            Severity: Minor
            Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

            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 DagreLayoutMin has 295 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            var DagreLayoutMin = (function () {
                function DagreLayoutMin() {
                }
                DagreLayoutMin.prototype.layout = function (graph, node) {
                    var g, layoutNode, nodes, newEdge, edges;
            Severity: Major
            Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

              Method getValue has a Cognitive Complexity of 74 (exceeds 5 allowed). Consider refactoring.
              Open

                public Object getValue(Object key) {
                  int pos = indexOf(key);
                  if (pos >= 0) {
                    if ((flag & MAP) == MAP) {
                      return this.getByIndex(SMALL_VALUE, pos + index, size);
              Severity: Minor
              Found in src/main/java/de/uniks/networkparser/list/AbstractArray.java - About 1 day to fix

              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 ./VirtualKeyBoard.ts has a Cognitive Complexity of 74 (exceeds 5 allowed). Consider refactoring.
              Open

              /***/ (function(module, exports, __webpack_require__) {
              
              "use strict";
              
              var __extends = (this && this.__extends) || (function () {
              Severity: Minor
              Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

              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/AddNode.ts has a Cognitive Complexity of 74 (exceeds 5 allowed). Consider refactoring.
              Open

              /***/ (function(module, exports, __webpack_require__) {
              
              "use strict";
              
              Object.defineProperty(exports, "__esModule", { value: true });
              Severity: Minor
              Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

              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

              AbstractArray has 78 methods (exceeds 20 allowed). Consider refactoring.
              Open

              public abstract class AbstractArray<V> implements BaseItem {
                /** Is Allow Duplicate Items in List */
                public static final byte ALLOWDUPLICATE = 0x01;
                /** Is Allow Empty Value in List (null) */
                public static final byte ALLOWEMPTYVALUE = 0x02;
              Severity: Major
              Found in src/main/java/de/uniks/networkparser/list/AbstractArray.java - About 1 day to fix

                Function ./elements/nodes/Form.ts has a Cognitive Complexity of 72 (exceeds 5 allowed). Consider refactoring.
                Open

                /***/ (function(module, exports, __webpack_require__) {
                
                "use strict";
                
                var __extends = (this && this.__extends) || (function () {
                Severity: Minor
                Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

                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

                NetworkParserLoger4J has 76 methods (exceeds 20 allowed). Consider refactoring.
                Open

                public class NetworkParserLoger4J extends NetworkParserLog implements SLF4JServiceProvider, ILoggerFactory, IMarkerFactory, MDCAdapter, Logger {
                //    private final ConcurrentMap<String, Marker> markerMap = new ConcurrentHashMap<String, Marker>();
                
                    @Override
                    public void initialize() {
                Severity: Major
                Found in src/gitsrc/java/de/uniks/networkparser/NetworkParserLoger4J.java - About 1 day to fix
                  Severity
                  Category
                  Status
                  Source
                  Language