* own subclass of {@link ListenableFuture}, complete with a method like {@link #from} to adapt an
 * existing {@code ListenableFuture}, implemented atop a {@link ForwardingListenableFuture} that
 * forwards to that future and adds the desired methods.
 */
@GwtCompatible
final class ForwardingFluentFuture<V extends @Nullable Object> extends FluentFuture<V> {
  private final ListenableFuture<V> delegate;

      if (newCapacity < 0) {
        newCapacity = Integer.MAX_VALUE;
        // guaranteed to be >= newCapacity
      }
      return newCapacity;
    }

    Builder() {}

    /**
     * Adds {@code element} to the {@code ImmutableCollection} being built.
     *
     * <p>Note that each builder class covariantly returns its own type from this method.
     *
     * @param element the element to add

     */
    public SuggestSettingsBuilder setSettingsIndexName(final String settingsIndexName) {
        this.settingsIndexName = settingsIndexName.toLowerCase(Locale.ENGLISH);
        return this;
    }

    /**
     * Adds an initial setting.
     * @param key The key of the setting.
     * @param value The value of the setting.
     * @return This builder instance.
     */

package com.google.common.graph;

import static com.google.common.base.Preconditions.checkNotNull;

import java.util.Map;
import org.jspecify.annotations.Nullable;

/**
 * A {@link MapIteratorCache} that adds additional caching. In addition to the caching provided by
 * {@link MapIteratorCache}, this structure caches values for the two most recently retrieved keys.
 *
 * @author James Sexton
 */

import javax.inject.Inject

/**
 * This task scans the main source set and findd samples in javadoc with `class='autoTested'`,
 * then generates a subclass of AbstractAutoTestedSamplesTest for each class including samples and adds them to the integTest.
 *
 * For example, we have two classes ABC.java and XYZ.groovy that include `class='autoTested'`,
 * there will be two files generated: `ABCAutoTestedSamplesTest.groovy` and `XYZAutoTestedSamplesTest.groovy`

                indexingHelper.sendDocuments(searchEngineClient, docList);
            }
        }
    }

    /**
     * Adds click count information to the document.
     *
     * @param doc the document to update
     * @param url the URL to get click count for
     * @param clickCountField the field name to store click count
     */

     * @param queryBuilder The query builder.
     */
    public void setQuery(final QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
    }

    /**
     * Adds a sort builder.
     * @param sortBuilder The sort builder.
     */
    public void addSort(final SortBuilder<?> sortBuilder) {
        sortList.add(sortBuilder);
    }

    /**

     * with that name, they are all replaced.
     */
    open fun header(
      name: String,
      value: String,
    ) = apply {
      headers[name] = value
    }

    /**
     * Adds a header with [name] and [value]. Prefer this method for multiply-valued
     * headers like "Cookie".
     *
     * Note that for some headers including `Content-Length` and `Content-Encoding`,

        if ("text/html".equals(mimeType) || "application/xhtml+xml".equals(mimeType)) {
            return true;
        }
        return false;
    }

    /**
     * Adds a rule for extracting child URLs from HTML tags.
     *
     * @param tagName the HTML tag name
     * @param attrName the attribute name to extract URLs from
     */

  private final Object lock = new Object();

  /** We will keep a private list of all logged records */
  @GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }