V entryValue = e.getValue();

            if (entryValue == null) {
              ++modCount;
              setValue(e, value);
              newCount = this.count; // count remains unchanged
              this.count = newCount; // write-volatile
              return null;
            } else if (onlyIfAbsent) {
              // Mimic
              // "if (!map.containsKey(key)) ...

expanded_policy_count=$(./mc admin policy list myminio/ | wc -l)

if [ $user_count -ne $expanded_user_count ]; then
	echo "BUG: original user count differs from expanded setup"
	exit 1
fi

if [ $policy_count -ne $expanded_policy_count ]; then
	echo "BUG: original policy count  differs from expanded setup"
	exit 1
fi

./mc version info myminio/versioned | grep -q "versioning is enabled"
ret=$?
if [ $ret -ne 0 ]; then

   * Returns a {@code new Object()} for every request, and increments a counter for every request.
   * The count is accessible via {@link #getCount}.
   */
  static class CountingLoader extends CacheLoader<Object, Object> {
    private final AtomicInteger count = new AtomicInteger();

    @Override
    public Object load(Object from) {
      count.incrementAndGet();
      return new Object();
    }

    public int getCount() {

| `minio_cluster_health_drives_offline_count`        | Count of offline drives in the cluster. <br><br>Type: gauge         |        |
| `minio_cluster_health_drives_online_count`         | Count of online drives in the cluster. <br><br>Type: gauge          |        |
| `minio_cluster_health_drives_count`                | Count of all drives in the cluster. <br><br>Type: gauge             |        |

  DescendingImmutableSortedMultiset(ImmutableSortedMultiset<E> forward) {
    this.forward = forward;
  }

  @Override
  public int count(@CheckForNull Object element) {
    return forward.count(element);
  }

  @Override
  @CheckForNull
  public Entry<E> firstEntry() {
    return forward.lastEntry();
  }

  @Override
  @CheckForNull

                    return BucketOrder.key(asc);
                }
                if ("count".equals(values[0])) {
                    return BucketOrder.count(asc);
                }
            }
        }
        return BucketOrder.count(false);
    }

    public void addQuery(final String s) {
        if (query == null) {
            query = new String[] { s };

            .setDefaultRequestConfig(requestBuilder.build()).build();

        Queue<String> queue = getUrls();

        String url;
        int count = 0;
        while((url = queue.poll()) != null && count < max) {

            try {
                Logger.info("crawling: " + url);
                HttpUriRequest request = new HttpGet(url);

   * support concurrent multisets whose content may change while the method is running.
   *
   * <p>The serialized output consists of the number of distinct elements, the first element, its
   * count, the second element, its count, and so on.
   */
  static <E extends @Nullable Object> void writeMultiset(
      Multiset<E> multiset, ObjectOutputStream stream) throws IOException {
    int entryCount = multiset.entrySet().size();

            return new ApiResult(this);
        }
    }

    public static class ApiDeleteResponse extends ApiResponse {
        protected long count = 1;

        public ApiDeleteResponse count(final long count) {
            this.count = count;
            return this;
        }

        @Override
        public ApiResult result() {
            return new ApiResult(this);
        }
    }

import jakarta.annotation.Resource;

public class SearchLogService {

    private static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";

    private static final String COUNT = "count";

    private static final String KEY = "key";

    private static final String ID = "id";

    private static final String USER_INFO_ID = "userInfoId";