*
     * @return A <code>String</code> containing the supplied domain.
     */
    public String getSuppliedDomain() {
        return suppliedDomain;
    }

    /**
     * Sets the supplied authentication domain for this message.
     *
     * @param suppliedDomain The supplied domain for this message.
     */
    public void setSuppliedDomain(final String suppliedDomain) {

    return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
  }

  static <E extends @Nullable Object> Set<E> newHashSetWithExpectedSize(int expectedSize) {
    return Sets.newHashSetWithExpectedSize(expectedSize);
  }

  static <E extends @Nullable Object> Set<E> newConcurrentHashSet() {
    // GWT's ConcurrentHashMap is a wrapper around HashMap, but it rejects null keys, which matches

    }

    /**
     * Sets the maximum buffer size for this transaction
     * @param maxBufferSize
     *            the maxBufferSize to set
     */
    public final void setMaxBufferSize(final int maxBufferSize) {
        this.maxBufferSize = maxBufferSize;
    }

    /**
     * Sets the maximum data count for this transaction
     * @param maxDataCount

     * Gets the current boost expression.
     *
     * @return the boost expression string
     */
    public String getBoostExpression() {
        return boostExpression;
    }

    /**
     * Sets the boost expression used to calculate boost values.
     *
     * @param expression the boost expression string
     */
    public void setBoostExpression(final String expression) {
        boostExpression = expression;

  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * SetMultimap.asMap essentially returns a Map<K, Set<V>>; we just can't declare it that way.
   * Thus, calls like asMap().values().remove(someSet) are safe because they are comparing a set to
   * a collection of other sets.
   */
  @SuppressWarnings("CollectionUndefinedEquality")
  public void testValuesRemove() {

    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));
    assertTrue(set.contains(3));
    assertFalse(set.contains(4));
    set = ContiguousSet.create(Range.open(0, 4), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));

     */
    @Override
    public boolean isFragment() {
        return queryBuilder.isFragment();
    }

    /**
     * Sets the query name.
     *
     * @param queryName the query name to set
     * @return the query builder
     */
    @Override
    public QueryBuilder queryName(final String queryName) {
        return queryBuilder.queryName(queryName);
    }

 */
class SpecificHostSocketFactory(
  val defaultAddress: InetSocketAddress?,
) : DelegatingSocketFactory(getDefault()) {
  private val hostMapping = mutableMapOf<InetAddress, InetSocketAddress>()

  /** Sets the [real] address for [requested].  */
  operator fun set(
    requested: InetAddress,
    real: InetSocketAddress,
  ) {

 * to reference a specific file using its file ID.
 *
 * @author mbechler
 */
public interface RequestWithFileId {

    /**
     * Sets the file ID for this request.
     *
     * @param fileId the file ID to set
     */
    void setFileId(byte[] fileId);

  }

  /**
   * Construct a new {@link java.util.Set} that is the intersection of the given sets.
   *
   * @deprecated Use {@link com.google.common.collect.Sets#intersection(Set, Set)} instead.
   */
  @Deprecated
  public static <T> Set<T> intersection(Set<? extends T> set1, Set<? extends T> set2) {
    Set<T> result = copyToSet(set1);
    result.retainAll(set2);
    return result;
  }

  private FeatureUtil() {}