-
Notifications
You must be signed in to change notification settings - Fork 5.4k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
8308167: SequencedMap::firstEntry throws NPE when first entry has nul…
…l key or value Reviewed-by: bchristi
- Loading branch information
Stuart Marks
committed
Jun 6, 2023
1 parent
4b15349
commit 6d155a4
Showing
4 changed files
with
214 additions
and
6 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
166 changes: 166 additions & 0 deletions
166
src/java.base/share/classes/jdk/internal/util/NullableKeyValueHolder.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,166 @@ | ||
| /* | ||
| * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved. | ||
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | ||
| * | ||
| * This code is free software; you can redistribute it and/or modify it | ||
| * under the terms of the GNU General Public License version 2 only, as | ||
| * published by the Free Software Foundation. Oracle designates this | ||
| * particular file as subject to the "Classpath" exception as provided | ||
| * by Oracle in the LICENSE file that accompanied this code. | ||
| * | ||
| * This code is distributed in the hope that it will be useful, but WITHOUT | ||
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
| * version 2 for more details (a copy is included in the LICENSE file that | ||
| * accompanied this code). | ||
| * | ||
| * You should have received a copy of the GNU General Public License version | ||
| * 2 along with this work; if not, write to the Free Software Foundation, | ||
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| * | ||
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | ||
| * or visit www.oracle.com if you need additional information or have any | ||
| * questions. | ||
| */ | ||
|
|
||
| package jdk.internal.util; | ||
|
|
||
| import java.util.Map; | ||
| import java.util.Objects; | ||
|
|
||
| /** | ||
| * An immutable container for a key and a value, both of which are nullable. | ||
| * | ||
| * <p>This is a <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a> | ||
| * class; programmers should treat instances that are | ||
| * {@linkplain #equals(Object) equal} as interchangeable and should not | ||
| * use instances for synchronization, or unpredictable behavior may | ||
| * occur. For example, in a future release, synchronization may fail. | ||
| * | ||
| * @apiNote | ||
| * This class is not exported. Instances are created by various Map implementations | ||
| * when they need a Map.Entry that isn't connected to the Map. | ||
| * | ||
| * <p>This class differs from AbstractMap.SimpleImmutableEntry in that it is not | ||
| * serializable and that it is final. This class differs from java.util.KeyValueHolder | ||
| * in that the key and value are nullable. | ||
| * | ||
| * <p>In principle this class could be a variation on KeyValueHolder. However, | ||
| * making that class selectively support nullable keys and values is quite intricate. | ||
| * Various specifications (such as Map.ofEntries and Map.entry) specify non-nullability | ||
| * of the key and the value. Map.Entry.copyOf also requires non-null keys and values; | ||
| * but it simply passes through KeyValueHolder instances, assuming their keys and values | ||
| * are non-nullable. If a KVH with nullable keys and values were introduced, some way | ||
| * to distinguish it would be necessary. This could be done by introducing a subclass | ||
| * (requiring KVH to be made non-final) or by introducing some kind of "mode" field | ||
| * (potentially increasing the size of every KVH instance, though another field could | ||
| * probably fit into the object's padding in most JVMs.) More critically, a mode field | ||
| * would have to be checked in all the right places to get the right behavior. | ||
| * | ||
| * <p>A longer range possibility is to selectively relax the restrictions against nulls in | ||
| * Map.entry and Map.Entry.copyOf. This would also require some intricate specification | ||
| * changes and corresponding implementation changes (e.g., the implementations backing | ||
| * Map.of might still need to reject nulls, and so would Map.ofEntries) but allowing | ||
| * a Map.Entry itself to contain nulls seems beneficial in general. If this is done, | ||
| * merging KeyValueHolder and NullableKeyValueHolder should be reconsidered. | ||
| * | ||
| * @param <K> the key type | ||
| * @param <V> the value type | ||
| */ | ||
| @jdk.internal.ValueBased | ||
| public final class NullableKeyValueHolder<K,V> implements Map.Entry<K,V> { | ||
| final K key; | ||
| final V value; | ||
|
|
||
| /** | ||
| * Constructs a NullableKeyValueHolder. | ||
| * | ||
| * @param k the key, may be null | ||
| * @param v the value, may be null | ||
| */ | ||
| public NullableKeyValueHolder(K k, V v) { | ||
| key = k; | ||
| value = v; | ||
| } | ||
|
|
||
| /** | ||
| * Constructs a NullableKeyValueHolder from a Map.Entry. No need for an | ||
| * idempotent copy at this time. | ||
| * | ||
| * @param entry the entry, must not be null | ||
| */ | ||
| public NullableKeyValueHolder(Map.Entry<K,V> entry) { | ||
| Objects.requireNonNull(entry); | ||
| key = entry.getKey(); | ||
| value = entry.getValue(); | ||
| } | ||
|
|
||
| /** | ||
| * Gets the key from this holder. | ||
| * | ||
| * @return the key, may be null | ||
| */ | ||
| @Override | ||
| public K getKey() { | ||
| return key; | ||
| } | ||
|
|
||
| /** | ||
| * Gets the value from this holder. | ||
| * | ||
| * @return the value, may be null | ||
| */ | ||
| @Override | ||
| public V getValue() { | ||
| return value; | ||
| } | ||
|
|
||
| /** | ||
| * Throws {@link UnsupportedOperationException}. | ||
| * | ||
| * @param value ignored | ||
| * @return never returns normally | ||
| */ | ||
| @Override | ||
| public V setValue(V value) { | ||
| throw new UnsupportedOperationException("not supported"); | ||
| } | ||
|
|
||
| /** | ||
| * Compares the specified object with this entry for equality. | ||
| * Returns {@code true} if the given object is also a map entry and | ||
| * the two entries' keys and values are equal. | ||
| */ | ||
| @Override | ||
| public boolean equals(Object o) { | ||
| return o instanceof Map.Entry<?, ?> e | ||
| && Objects.equals(key, e.getKey()) | ||
| && Objects.equals(value, e.getValue()); | ||
| } | ||
|
|
||
| private int hash(Object obj) { | ||
| return (obj == null) ? 0 : obj.hashCode(); | ||
| } | ||
|
|
||
| /** | ||
| * Returns the hash code value for this map entry. The hash code | ||
| * is {@code key.hashCode() ^ value.hashCode()}. | ||
| */ | ||
| @Override | ||
| public int hashCode() { | ||
| return hash(key) ^ hash(value); | ||
| } | ||
|
|
||
| /** | ||
| * Returns a String representation of this map entry. This | ||
| * implementation returns the string representation of this | ||
| * entry's key followed by the equals character ("{@code =}") | ||
| * followed by the string representation of this entry's value. | ||
| * | ||
| * @return a String representation of this map entry | ||
| */ | ||
| @Override | ||
| public String toString() { | ||
| return key + "=" + value; | ||
| } | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
6d155a4There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Review
Issues