}

        if (states.count(RUNNING) == numberOfServices) {
          // This means that the manager is currently healthy. N.B. If other threads call isHealthy
          // they are not guaranteed to get 'true', because any service could fail right now.
          enqueueHealthyEvent();
        } else if (states.count(TERMINATED) + states.count(FAILED) == numberOfServices) {
          enqueueStoppedEvent();

        accessResult.init(responseData, resultData);
        return accessResult;
    }

    /**
     * Checks if the access count is within the allowed limit.
     *
     * @param crawlerContext the crawler context
     * @return true if access count is within limit, false otherwise
     */
    protected boolean checkAccessCount(final CrawlerContext crawlerContext) {

        try {
            final Object content = message.getContent();
            if (content instanceof final Multipart multipart) {
                final int count = multipart.getCount();
                for (int i = 0; i < count; i++) {
                    final BodyPart bodyPart = multipart.getBodyPart(i);
                    if (Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition())) {

  public void testElementSetRemovePropagatesToMultiset() {
    Set<E> elementSet = getMultiset().elementSet();
    int size = getNumElements();
    int expectedSize = size - getMultiset().count(e0());
    assertTrue(elementSet.remove(e0()));
    assertFalse(getMultiset().contains(e0()));
    assertEquals(expectedSize, getMultiset().size());
  }

  @CollectionSize.Require(SEVERAL)

     */
    void store(DataStoreParams paramMap, Map<String, Object> dataMap);

    /**
     * Returns the total number of documents processed by this callback.
     *
     * @return the document count
     */
    long getDocumentSize();

    /**
     * Returns the total execution time for index update operations.
     *
     * @return the execution time in milliseconds
     */
    long getExecuteTime();

        /**
         * Expiry time threshold for file deletion.
         */
        protected final long expiry;

        /**
         * Count of processed files.
         */
        protected long count;

        /**
         * Maximum number of files to purge in a single operation.
         */
        protected final int maxPurgeSize;

        /**

    if (entries.size() >= 1) {
      a = Multisets.immutableEntry(entries.get(0), sortedMultiset.count(entries.get(0)));
      if (entries.size() >= 3) {
        b = Multisets.immutableEntry(entries.get(1), sortedMultiset.count(entries.get(1)));
        c = Multisets.immutableEntry(entries.get(2), sortedMultiset.count(entries.get(2)));
      }
    }
  }

         *
         * @return time of first failure
         */
        public long getFailureTime() {
            return failureTime;
        }

        /**
         * Get retry count
         *
         * @return number of retry attempts
         */
        public int getRetryCount() {
            return retryCount;
        }

        /**
         * Get next retry time

  private static boolean isPermutation(List<?> first, List<?> second) {
    if (first.size() != second.size()) {
      return false;
    }
    ObjectCountHashMap<?> firstCounts = counts(first);
    ObjectCountHashMap<?> secondCounts = counts(second);
    if (first.size() != second.size()) {
      return false;
    }
    for (int i = 0; i < first.size(); i++) {

                : this.transportContext.getConfig().getWinsServers()[this.nbnsIndex];
    }

    static class Sem {

        Sem(final int count) {
            this.count = count;
        }

        int count;
    }

    static class QueryThread extends Thread {

        private final Sem sem;
        private final String host, scope;
        private final int type;