Method ns_initialize has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

      def ns_initialize(opts)
        min_length       = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
        max_length       = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
        idletime         = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
        @max_queue       = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i

• Read up
  Read up

Method readObject has 71 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    @SuppressWarnings("unchecked") private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        this.segments = null; // unneeded
        // initialize transient final field

Method readObject has 71 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    @SuppressWarnings("unchecked") private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        this.segments = null; // unneeded
        // initialize transient final field

Method acquire_write_lock has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def acquire_write_lock
      while true
        c = @Counter.value
        raise ResourceLimitError.new('Too many writer threads') if max_writers?(c)

• Read up
  Read up

Method wait_until_resolved has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

      def wait_until_resolved(timeout)
        return true if resolved?

        touch

• Read up
  Read up

Method equals has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    public boolean equals(Object o) {
        if (o != this) {
            if (!(o instanceof Map))
                return false;
            Map<?,?> m = (Map<?,?>) o;

• Read up
  Read up

Method internalGet has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    private final Object internalGet(Object k) {
        int h = spread(k.hashCode());
        retry: for (Node[] tab = table; tab != null;) {
            Node e, p; Object ek, ev; int eh;      // locals to read fields once
            for (e = tabAt(tab, (tab.length - 1) & h); e != null; e = e.next) {

• Read up
  Read up

Method equals has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    public boolean equals(Object o) {
        if (o != this) {
            if (!(o instanceof Map))
                return false;
            Map<?,?> m = (Map<?,?>) o;

• Read up
  Read up

Method internalGet has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    private final Object internalGet(Object k) {
        int h = spread(k.hashCode());
        retry: for (AtomicReferenceArray<Node> tab = table; tab != null;) {
            Node e, p; Object ek, ev; int eh;      // locals to read fields once
            for (e = tabAt(tab, (tab.length() - 1) & h); e != null; e = e.next) {

• Read up
  Read up

Method internal_receive has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

      def internal_receive
        raise if @behaviour.empty?
        rules_matcher  = Or[*@behaviour.map(&:first)]
        matcher        = -> m { m.is_a?(Ask) ? rules_matcher === m.message : rules_matcher === m }
        start          = nil

• Read up
  Read up

Method canonical_rules has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

      def canonical_rules(rules, timeout, timeout_value, given_block)
        block = given_block || -> v { v }
        case rules.size
        when 0
          rules.push(on(ANY, &block))

• Read up
  Read up

Method ns_consume_pending_push has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

      def ns_consume_pending_push(matcher, remove = true)
        i = 0
        while true
          message, pushed = @PendingPush[i, 2]
          return NOTHING unless pushed

• Read up
  Read up

Class NonConcurrentMapBackend has 22 methods (exceeds 20 allowed). Consider refactoring.

Open

    class NonConcurrentMapBackend

      # WARNING: all public methods of the class must operate on the @backend
      # directly without calling each other. This is important because of the
      # SynchronizedMapBackend which uses a non-reentrant mutex for performance

Class Base has 22 methods (exceeds 20 allowed). Consider refactoring.

Open

      class Base < Synchronization::LockableObject

        # @!macro channel_buffer_capacity_reader
        #
        #   The maximum number of values which can be {#put} onto the buffer

Method internalClear has 58 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private final void internalClear() {
        long delta = 0L; // negative number of deletions
        int i = 0;
        Node[] tab = table;
        while (tab != null && i < tab.length) {

Method internalClear has 58 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private final void internalClear() {
        long delta = 0L; // negative number of deletions
        int i = 0;
        AtomicReferenceArray<Node> tab = table;
        while (tab != null && i < tab.length()) {

Method validate has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def validate(value, allow_nil, raise_error)
      if !allow_nil && value.nil?
        raise_error ? raise(ValidationError.new('nil is not a valid value')) : false
      elsif !validator.call(value)
        raise_error ? raise(ValidationError) : false

• Read up
  Read up

Method value has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def value(timeout = nil)
      if @executor # TODO (pitr 12-Sep-2015): broken unsafe read?
        super
      else
        # this function has been optimized for performance and

• Read up
  Read up

Method find has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

        def self.find(head, item)
          loop do
            break_inner_loops = false
            pred = head
            curr = pred.next_node

• Read up
  Read up

Class Map has 21 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Map < Collection::MapImplementation

    # @!macro map.atomic_method
    #   This method is atomic.