Avoid deeply nested control flow statements.

Open

                        if (busy == 0 && casBusy()) {
                            boolean created = false;
                            try {               // Recheck under lock
                                Cell[] rs; int m, j;
                                if ((rs = cells) != null &&

Avoid deeply nested control flow statements.

Open

                                        if (count >= TREE_THRESHOLD)
                                            replaceWithTreeBin(tab, i, k);

Avoid deeply nested control flow statements.

Open

                            if ((pr = p.right) != null && h >= pr.hash && (r = getTreeNode(h, k, pr)) != null)
                                return r;
                            // try to continue iterating on the left side
                            else if ((pl = p.left) != null && h <= pl.hash)
                                dir = -1;

Avoid deeply nested control flow statements.

Open

                                    if ((e.val = v) == null) {
                                        deleted = true;
                                        Node en = e.next;
                                        if (pred != null)
                                            pred.next = en;

Avoid deeply nested control flow statements.

Open

                        for (Node e = tabAt(tab, i); e != null; e = e.next) {
                            if (++c > TREE_THRESHOLD &&
                                    (e.key instanceof Comparable)) {
                                replaceWithTreeBin(tab, i, e.key);
                                break;

Method writeObject has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    @SuppressWarnings("unchecked") private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        if (segments == null) { // for serialization compatibility
            segments = (Segment<K,V>[])
                    new Segment<?,?>[DEFAULT_CONCURRENCY_LEVEL];

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                            if ((pr = p.right) != null && h >= pr.hash && (r = getTreeNode(h, k, pr)) != null)
                                return r;
                            else // continue descending down the left subtree
                                dir = -1;

Method para_prepare has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

def para_prepare(&block)
  num_threads = $conf[:num_threads]
  count = $conf[:count_per_thread]

  if num_threads % 2 > 0

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                                        if (count >= TREE_THRESHOLD)
                                            replaceWithTreeBin(tab, i, k);

Method ns_wait_until has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def ns_wait_until(timeout = nil, &condition)
        if timeout
          wait_until = Concurrent.monotonic_time + timeout
          loop do
            now = Concurrent.monotonic_time

• Read up
  Read up

Method on_envelope has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def on_envelope(envelope)
          command, reason = envelope.message
          case command
          when :terminated?
            terminated?

• Read up
  Read up

Method consume_signal has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def consume_signal(message)
        if AbstractSignal === message
          case message
          when Ask
            @reply = message.probe

• Read up
  Read up

Method initialize has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def initialize(delayed, blockers_count, default_executor, executor, args, &task)

Method reason has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def reason(timeout = nil, timeout_value = nil, resolve_on_timeout = nil)
        if wait_until_resolved timeout
          internal_state.reason
        else
          if resolve_on_timeout

• Read up
  Read up

Method resolve_with has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def resolve_with(state, raise_on_reassign = true, reserved = false)
        if compare_and_set_internal_state(reserved ? RESERVED : PENDING, state)
          # go to synchronized block only if there were waiting threads
          @Lock.synchronize { @Condition.broadcast } unless @Waiters.value == 0
          call_callbacks state

• Read up
  Read up

Method ns_shift_message has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def ns_shift_message(matcher, remove = true)
        i = 0
        while true
          message = @Messages.fetch(i, NOTHING)
          return NOTHING if message == NOTHING

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

            break if !running_writer?(c) && !running_readers?(c) && @Counter.compare_and_set(c, c+RUNNING_WRITER-WAITING_WRITER)

Method link has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def link(pid)
        return true if pid == @Pid
        if @Linked.add? pid
          pid.tell Link.new(@Pid)
          if pid.terminated.resolved?

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

            elsif @Counter.compare_and_set(c, c+1)
              @HeldCount.value = held + 1
              return true

Method initialize has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def initialize(delayed, blockers_count, default_executor, executor, args, &task)