*       be thrown using {@code Throwable.addSuppressed(Throwable)}.
 *   <li><b>Java 6:</b> Exceptions are suppressed by logging them instead.
 * </ul>
 *
 * @author Colin Decker
 * @since 14.0
 */
// Coffee's for {@link Closer closers} only.
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class Closer implements Closeable {

   */
  @CanIgnoreReturnValue
  @Override
  public boolean add(E element) {
    offer(element);
    return true;
  }

  @CanIgnoreReturnValue
  @Override
  public boolean addAll(Collection<? extends E> newElements) {
    boolean modified = false;
    for (E element : newElements) {
      offer(element);
      modified = true;
    }
    return modified;
  }

  /**

  public void testOffer_supportedNotPresent() {
    assertTrue("offer(notPresent) should return true", getQueue().offer(e3()));
    expectAdded(e3());
  }

  @CollectionFeature.Require({SUPPORTS_ADD, ALLOWS_NULL_VALUES})
  public void testOffer_nullSupported() {
    assertTrue("offer(null) should return true", getQueue().offer(null));
    expectAdded((E) null);
  }

                final String thumbnailField = fessConfig.getIndexFieldThumbnail();
                docList.stream().forEach(doc -> {
                    if (!thumbnailManager.offer(doc)) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Removing {}={} from doc[{}]", thumbnailField, doc.get(thumbnailField),

      int k, Comparator<? super T> comparator) {
    checkNonnegative(k, "k");
    checkNotNull(comparator);
    return Collector.of(
        () -> TopKSelector.<T>least(k, comparator),
        TopKSelector::offer,
        TopKSelector::combine,
        TopKSelector::topK,
        Collector.Characteristics.UNORDERED);
  }

  /**

     * on what they know about the particular Joiner instances the calls are performed on.
     *
     * (In addition to useForNull, we also offer skipNulls. It, too, tolerates null inputs, but its
     * tolerance is implemented differently: Its implementation avoids calling this toString(Object)
     * method in the first place.)
     */
    requireNonNull(part);

    for (int i = 0; i < 10; i++) {
      top.offer(i);
    }
    assertThat(top.topK()).isEmpty();
  }

  public void testNoElementsOffered() {
    TopKSelector<Integer> top = TopKSelector.least(10);
    assertThat(top.topK()).isEmpty();
  }

  public void testOfferedFewerThanK() {
    TopKSelector<Integer> top = TopKSelector.least(10);
    top.offer(3);
    top.offer(5);
    top.offer(2);

 * tailored to that use case.
 *
 * <p>This uses the same efficient implementation as {@link Ordering#leastOf(Iterable, int)},
 * offering expected O(n + k log k) performance (worst case O(n log k)) for n calls to {@link
 * #offer} and a call to {@link #topK}, with O(k) memory. In comparison, quickselect has the same
 * asymptotics but requires O(n) memory, and a {@code PriorityQueue} implementation takes O(n log

            long counter = 0;
            final Deque<String> urlQueue = new LinkedList<>();
            final Set<String> processedUrls = new HashSet<>();
            urlQueue.offer(url);
            while (!urlQueue.isEmpty() && (maxAccessCount < 0 || counter < maxAccessCount)) {
                counter++;
                final Map<String, Object> localDataMap =

        }

        final File thumbnailFile = thumbnailManager.getThumbnailFile(doc);
        if (thumbnailFile == null) {
            if (fessConfig.isThumbnailEnabled()) {
                thumbnailManager.offer(doc);
            }
            // 404
            throw responseManager.new404("Thumbnail for " + form.docId + " is under generating.");
        }