public <T> T[] toArray(T[] a) {
    E[] items = this.items;
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      if (a.length < count) a = ObjectArrays.newArray(a, count);

      int k = 0;
      int i = takeIndex;
      while (k < count) {
        // This cast is not itself safe, but the following statement
        // will fail if the runtime type of items[i] is not assignable

        final SearchLogHelper searchLogHelper = ComponentUtil.getSearchLogHelper();
        final int count = searchLogHelper.getClickCount(url);
        doc.put(clickCountField, count);
        if (logger.isDebugEnabled()) {
            logger.debug("Click Count: {}, url: {}", count, url);
        }
    }

    /**
     * Adds favorite count information to the document.
     *
     * @param doc the document to update

	LastMinute  ReplicationLastMinute
	// Error counts
	ErrCounts map[string]int `json:"errCounts"` // Count of credential errors
}

func (rt *RTimedMetrics) String() string {
	s := rt.toMetric()
	return fmt.Sprintf("Errors in LastMinute: %v, LastHour: %v, SinceUptime: %v", s.LastMinute.Count, s.LastHour.Count, s.Totals.Count)
}

func (rt *RTimedMetrics) toMetric() madmin.TimedErrStats {
	if rt == nil {

./mc admin decom start myminio/ http://localhost:9000/tmp/xl/{1...10}/disk{0...1}

count=0
until $(./mc admin decom status myminio/ | grep -q Complete); do
	echo "waiting for decom to finish..."
	count=$((count + 1))
	if [ ${count} -eq 120 ]; then
		./mc cat /tmp/expanded_*.log
	fi
	sleep 1
done

kill $pid_1
kill $pid_2

sleep 5

				if err != nil {
					err = msgp.WrapError(err, "Curr")
					return
				}
				switch msgp.UnsafeString(field) {
				case "Count":
					z.Curr.Count, err = dc.ReadFloat64()
					if err != nil {
						err = msgp.WrapError(err, "Curr", "Count")
						return
					}
				case "Bytes":
					z.Curr.Bytes, err = dc.ReadFloat64()
					if err != nil {
						err = msgp.WrapError(err, "Curr", "Bytes")

  @Override
  public int setCount(E element, int count) {
    checkIsE(element);
    checkNonnegative(count, "count");
    int index = element.ordinal();
    int oldCount = counts[index];
    counts[index] = count;
    size += count - oldCount;
    if (oldCount == 0 && count > 0) {
      distinctElements++;
    } else if (oldCount > 0 && count == 0) {
      distinctElements--;
    }
    return oldCount;

   *
   * <ul>
   *   <li>Both {@code xStats} and {@code yStats} must have the same {@code count}.
   *   <li>If that {@code count} is 1, {@code sumOfProductsOfDeltas} must be exactly 0.0.
   *   <li>If that {@code count} is more than 1, {@code sumOfProductsOfDeltas} must be finite.
   * </ul>
   */
  PairedStats(Stats xStats, Stats yStats, double sumOfProductsOfDeltas) {

    assertThat(emptyAccumulator.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(0);
    assertThat(oneValueAccumulator.count()).isEqualTo(1);
    assertThat(oneValueAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(1);
    assertThat(twoValuesAccumulator.count()).isEqualTo(2);
    assertThat(twoValuesAccumulatorByAddAllPartitionedPairedStats.count()).isEqualTo(2);

        }

        @Override
        public void dispose() {
            ++count;
            names += name;
        }
    }

    /**
     *
     */
    public class TestDisposable2 implements Disposable {
        @Override
        public void dispose() {
            ++count;
            throw new RuntimeException();
        }
    }

        byte[] buffer = new byte[] { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // count = 10

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // The count should be read from the buffer.
        assertEquals(10L, response.count);
        // The method should return the number of bytes read.
        assertEquals(8, bytesRead);
    }

    /**