ImmutableSet<C> columnSpace) {
    // use a dense table if more than half of the cells have values
    // TODO(gak): tune this condition based on empirical evidence
    return (cellList.size() > (((long) rowSpace.size() * columnSpace.size()) / 2))
        ? new DenseImmutableTable<R, C, V>(cellList, rowSpace, columnSpace)
        : new SparseImmutableTable<R, C, V>(cellList, rowSpace, columnSpace);
  }

  /**

     */
    public BaseSearchBody() {
        // Default constructor
    }

    /**
     * Gets the page size for search results.
     * @return The page size.
     */
    public int getPageSize() {
        if (size != null) {
            return size;
        }
        return ComponentUtil.getFessConfig().getPagingPageSizeAsInteger();
    }

    /**

    @Nullable Node<K, V> previous;
    int expectedModCount = modCount;

    NodeIterator(int index) {
      int size = size();
      checkPositionIndex(index, size);
      if (index >= (size / 2)) {
        previous = tail;
        nextIndex = size;
        while (index++ < size) {
          previous();
        }
      } else {
        next = head;
        while (index-- > 0) {
          next();

    /**
     * Default maximum receive size (8KB)
     */
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;

    /**
     * Default maximum fragmented size (128KB)
     */
    public static final int DEFAULT_MAX_FRAGMENTED_SIZE = 131072; // 128KB

    /**
     * Default maximum read/write size (1MB)
     */
    public static final int DEFAULT_MAX_READ_WRITE_SIZE = 1048576; // 1MB

    assertEquals(1, Iterators.size(registry.getSubscribers(1)));

    registry.register(new IntegerSubscriber());
    assertEquals(3, Iterators.size(registry.getSubscribers("")));
    assertEquals(1, Iterators.size(registry.getSubscribers(new Object())));
    assertEquals(2, Iterators.size(registry.getSubscribers(1)));
  }

  public void testGetSubscribers_returnsImmutableSnapshot() {

    }

    /**
     * Get the preferred size for send operations
     *
     * @return preferred send size in bytes
     */
    public int getPreferredSendSize() {
        return preferredSendSize;
    }

    /**
     * Set the preferred size for send operations
     *
     * @param preferredSendSize preferred send size in bytes
     */

			N:     l.Totals[i].N + o.Totals[i].N,
			Size:  l.Totals[i].Size + o.Totals[i].Size,
		}
	}
	return merged
}

// Add  a new duration data
func (l *ReplicationLastHour) addsize(sz int64) {
	minutes := time.Now().Unix() / 60
	l.forwardTo(minutes)
	winIdx := minutes % 60
	l.Totals[winIdx].merge(AccElem{Total: minutes, Size: sz, N: 1})
	l.LastMin = minutes
}

        assertEquals(4, res.getVertices().size(), "wrong # of vertices in the resulting graph after resolver");
        assertEquals(
                2,
                res.getExcidentEdges(v1).size(),
                "wrong # of excident edges in the resulting graph entry after resolver");

        assertEquals(
                1,
                res.getIncidentEdges(v2).size(),

            assertEquals(2 + (count * 2), encoded);
            // Note: size() returns 4 + count*2, but encode returns 2 + count*2
            // This is an implementation inconsistency in the original code
            assertNotEquals(context.size(), encoded);
            assertEquals(4 + (count * 2), context.size());
        }

        @Test
        @DisplayName("Should encode and decode correctly")

}

// New returns a new RingBuffer whose buffer has the given size.
func New(size int) *RingBuffer {
	return &RingBuffer{
		buf:  make([]byte, size),
		size: size,
	}
}

// NewBuffer returns a new RingBuffer whose buffer is provided.
func NewBuffer(b []byte) *RingBuffer {
	return &RingBuffer{
		buf:  b,
		size: len(b),
	}
}

// SetBlocking sets the blocking mode of the ring buffer.