* PeekingIterator}</a>.
 *
 * @author Mick Killianey
 * @since 2.0
 */
@DoNotMock("Use Iterators.peekingIterator")
@GwtCompatible
public interface PeekingIterator<E extends @Nullable Object> extends Iterator<E> {
  /**
   * Returns the next element in the iteration, without advancing the iteration.
   *

    }

    /**
     * Gets the mechanism list MIC (Message Integrity Code) for integrity protection
     * @return the mechanism list MIC bytes
     */
    public byte[] getMechanismListMIC() {
        return this.mechanismListMIC;
    }

    /**
     * Sets the mechanism list MIC (Message Integrity Code) for integrity protection
     * @param mechanismListMIC the mechanism list MIC bytes
     */

  /**
   * Returns an immutable map containing the same entries as {@code map}. If {@code map} somehow
   * contains entries with duplicate keys (for example, if it is a {@code SortedMap} whose
   * comparator is not <i>consistent with equals</i>), the results of this method are undefined.
   *
   * <p><b>Note:</b> Despite what the method name suggests, if {@code map} is an {@code
   * ImmutableClassToInstanceMap}, no copy will actually be performed.

 * lead to unexpected behavior. In this case, you should override {@code add(Object)} as well,
 * either providing your own implementation, or delegating to the provided {@code standardAdd}
 * method.
 *
 * <p>The {@code standard} methods and any collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.

name: Chore
description: Minor issue without significant impact
labels: [ "a:chore", "to-triage" ]
assignees: [ ]
body:
  - type: dropdown
    id: issue-type
    attributes:
      label: Issue type
      options:
        - Polishing
        - Deprecation
        - Refactoring
        - Other
    validations:
      required: true
  - type: textarea
    id: description
    attributes:
      label: Problem description

Pod Priority and Preemption in Kubernetes ([#564](https://github.com/kubernetes/enhancements/issues/564))

- Pod priority and preemption enables Kubernetes scheduler to schedule more important Pods first and when cluster is out of resources, it removes less important pods to create room for more important ones. The importance is specified by priority.

     * </blockquote>
     */
    public static void registerSmbURLHandler() {
        SingletonContext.registerSmbURLHandler();
    }

    /**
     * Retrieve an <code>int</code>. If the key does not exist or
     * cannot be converted to an <code>int</code>, the provided default
     * argument will be returned.
     *
     * @param props the properties to search in
     * @param key the property key to look up

     * in which {@code Cursor} is {@code Closeable}. To support older versions, pass a wrapper
     * {@code Closeable} with a method reference like {@code cursor::close}.
     *
     * <p>Note that this method is still binary-compatible between flavors because the erasure of
     * its parameter type is {@code Object}, not {@code AutoCloseable} or {@code Closeable}.
     *

[codeofconduct_at]: mailto:******@****.***
[twitter_coc]: https://github.com/twitter/code-of-conduct/blob/master/code-of-conduct.md
[ubuntu_coc]: https://ubuntu.com/community/code-of-conduct
[gdc_coc]: https://www.gdconf.com/code-of-conduct

    return Double.toString(get());
  }

  /**
   * Returns the value of this {@code AtomicDouble} as an {@code int} after a narrowing primitive
   * conversion.
   */
  @Override
  public int intValue() {
    return (int) get();
  }

  /**
   * Returns the value of this {@code AtomicDouble} as a {@code long} after a narrowing primitive
   * conversion.
   */
  @Override