}

  val initialWindowSize: Int
    get() {
      val bit = 1 shl INITIAL_WINDOW_SIZE
      return if (bit and set != 0) values[INITIAL_WINDOW_SIZE] else DEFAULT_INITIAL_WINDOW_SIZE
    }

  fun clear() {
    set = 0
    values.fill(0)
  }

  operator fun set(
    id: Int,
    value: Int,
  ): Settings {
    if (id < 0 || id >= values.size) {
      return this // Discard unknown settings.
    }

          public void checkAccess(Thread t) {
            throw new SecurityException();
          }

          @Override
          public void checkPermission(Permission perm) {
            // Do nothing so we can clear the security manager at the end
          }
        });
    try {
      final String oldName = Thread.currentThread().getName();
      Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");

        Additionally, it's very useful to us if you can provide a "straw API" — what the
        method signatures would look like, for example, even if the method and class names are still
        in flux. This can make the feature you're suggesting much clearer to us.

  - type: textarea
    attributes:
      label: (Optional) What would the method signatures for your feature look like?
      placeholder: |
        e.g.,

 * {@link ReferenceQueue}.
 *
 * <p>Unlike a normal phantom reference, this reference will be cleared automatically.
 *
 * @author Bob Lee
 * @since 2.0
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public abstract class FinalizablePhantomReference<T> extends PhantomReference<T>
    implements FinalizableReference {
  /**

import jakarta.annotation.Resource;

/**
 * @author shinsuke
 * @author Keiichi Watanabe
 */
public class AdminRoleAction extends FessAdminAction {

    public static final String ROLE = "admin-role";

    private static final Logger logger = LogManager.getLogger(AdminRoleAction.class);

    // ===================================================================================

    K castKey = (K) key;
    List<V> oldValues = getCopy(castKey);
    removeAllNodes(castKey);
    return oldValues;
  }

  @Override
  public void clear() {
    head = null;
    tail = null;
    keyToKeyList.clear();
    size = 0;
    modCount++;
  }

  // Views

  /**
   * {@inheritDoc}
   *

   * Predicates.instanceOf(ArrayList.class)}, which is inconsistent with equals. (See {@link
   * Iterables#filter(Iterable, Class)} for related functionality.)
   *
   * @since 11.0
   */
  public static <E extends @Nullable Object> SortedSet<E> filter(
      SortedSet<E> unfiltered, Predicate<? super E> predicate) {
    if (unfiltered instanceof FilteredSet) {

  }

  @Override
  Spliterator<V> valueSpliterator() {
    return CollectSpliterators.map(entrySpliterator(), Entry::getValue);
  }

  @Override
  public void clear() {
    super.clear();
    succeedsInMultimap(multimapHeaderEntry, multimapHeaderEntry);
  }

  /**
   * @serialData the expected values per key, the number of distinct keys, the number of entries,

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;
import jcifs.smb.SmbFileInputStream;


/**
 * 
 *
 */
public class Lmhosts {

    private static final Logger log = LoggerFactory.getLogger(Lmhosts.class);

    private final Map<Name, NbtAddress> table = new HashMap<>();
    private long lastModified = 1L;
    private int alt;


    /**

    for (plan in tcpConnectsInFlight) {
      plan.cancel()
      val retry = plan.retry() ?: continue
      routePlanner.deferredPlans.addLast(retry)
    }
    tcpConnectsInFlight.clear()
  }