}

  @Override
  public final boolean retainAll(Collection<?> elementsToKeep) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final void clear() {
    throw new UnsupportedOperationException();
  }

  private transient @Nullable ImmutableList<E> asList;

  public ImmutableList<E> asList() {
    ImmutableList<E> list = asList;

     * Release all leases
     */
    public void releaseAll() {
        lock.writeLock().lock();
        try {
            log.info("Releasing all {} leases", leases.size());
            leases.clear();
            pathToLease.clear();
        } finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * Get all active leases
     *
     * @return map of lease keys to lease entries

    }

  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.
    }

    final Map<E, Integer> backingMap = new HashMap<>();

    @Override
    public int size() {
      return Multisets.linearTimeSizeImpl(this);
    }

    @Override
    public void clear() {
      throw new UnsupportedOperationException();
    }

    @Override
    public int count(@Nullable Object element) {
      for (Entry<E> entry : entrySet()) {

			if err != nil {
				err = msgp.WrapError(err, "Checksums")
				return
			}
			if z.Checksums == nil {
				z.Checksums = make(map[string]string, zb0002)
			} else if len(z.Checksums) > 0 {
				clear(z.Checksums)
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Checksums")
					return
				}

java.net.Inet6Address#getHostAddress()
java.net.InetSocketAddress#toString()

@defaultMessage avoid DNS lookups by accident: if you have a valid reason, then @SuppressWarnings with that reason so its completely clear
java.net.InetAddress#getHostName()
java.net.InetAddress#getCanonicalHostName()

java.net.InetSocketAddress#getHostName() @ Use getHostString() instead, which avoids a DNS lookup

    }

    @Override
    public Iterator<K> iterator() {
      return keySetIterator();
    }

    @Override
    public void clear() {
      CompactHashMap.this.clear();
    }
  }

  Iterator<K> keySetIterator() {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.keySet().iterator();
    }

        }
        t.join(timeoutMillis);
        return !t.isAlive();
    }

    /**
     * Clears the managed {@link TimeoutTask}.
     */
    public synchronized void clear() {
        timeoutTaskList.clear();
    }

    /**
     * Adds a {@link TimeoutTarget}.
     *
     * @param timeoutTarget the target
     * @param timeout the timeout duration

    return true;
  }

  @Override
  @CanIgnoreReturnValue
  public boolean addAll(Collection<? extends E> collection) {
    int size = collection.size();
    if (size >= maxSize) {
      clear();
      return Iterables.addAll(this, Iterables.skip(collection, size - maxSize));
    }
    return standardAddAll(collection);
  }

  @Override

	return r, nil
}

// Reset data in record.
func (r *Record) Reset() {
	if len(r.columnNames) > 0 {
		r.columnNames = r.columnNames[:0]
	}
	if len(r.csvRecord) > 0 {
		r.csvRecord = r.csvRecord[:0]
	}
	clear(r.nameIndexMap)
}

// Clone the record.
func (r *Record) Clone(dst sql.Record) sql.Record {
	other, ok := dst.(*Record)
	if !ok {
		other = &Record{}
	}
	if len(other.columnNames) > 0 {