com.google.common.collect.RegularImmutableMap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of guava-gwt Show documentation
Show all versions of guava-gwt Show documentation
Guava is a suite of core and expanded libraries that include
utility classes, Google's collections, I/O classes, and
much more.
This project includes GWT-friendly sources.
/*
* Copyright (C) 2008 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.collect;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkPositionIndex;
import static com.google.common.collect.CollectPreconditions.checkEntryNotNull;
import static com.google.common.collect.ImmutableMapEntry.createEntryArray;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMapEntry.NonTerminalImmutableMapEntry;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.Serializable;
import java.util.function.BiConsumer;
import org.checkerframework.checker.nullness.qual.Nullable;
/**
* Implementation of {@link ImmutableMap} with two or more entries.
*
* @author Jesse Wilson
* @author Kevin Bourrillion
* @author Gregory Kick
*/
@GwtCompatible(serializable = true, emulated = true)
final class RegularImmutableMap extends ImmutableMap {
@SuppressWarnings("unchecked")
static final ImmutableMap EMPTY =
new RegularImmutableMap<>((Entry[]) ImmutableMap.EMPTY_ENTRY_ARRAY, null, 0);
/**
* Closed addressing tends to perform well even with high load factors. Being conservative here
* ensures that the table is still likely to be relatively sparse (hence it misses fast) while
* saving space.
*/
@VisibleForTesting static final double MAX_LOAD_FACTOR = 1.2;
/**
* Maximum allowed false positive probability of detecting a hash flooding attack given random
* input.
*/
@VisibleForTesting static final double HASH_FLOODING_FPP = 0.001;
/**
* Maximum allowed length of a hash table bucket before falling back to a j.u.HashMap based
* implementation. Experimentally determined.
*/
@VisibleForTesting static final int MAX_HASH_BUCKET_LENGTH = 8;
// entries in insertion order
@VisibleForTesting final transient Entry[] entries;
// array of linked lists of entries
private final transient ImmutableMapEntry[] table;
// 'and' with an int to get a table index
private final transient int mask;
static ImmutableMap fromEntries(Entry... entries) {
return fromEntryArray(entries.length, entries);
}
/**
* Creates an ImmutableMap from the first n entries in entryArray. This implementation may replace
* the entries in entryArray with its own entry objects (though they will have the same key/value
* contents), and may take ownership of entryArray.
*/
static ImmutableMap fromEntryArray(int n, Entry[] entryArray) {
checkPositionIndex(n, entryArray.length);
if (n == 0) {
return (RegularImmutableMap) EMPTY;
}
Entry[] entries;
if (n == entryArray.length) {
entries = entryArray;
} else {
entries = createEntryArray(n);
}
int tableSize = Hashing.closedTableSize(n, MAX_LOAD_FACTOR);
ImmutableMapEntry[] table = createEntryArray(tableSize);
int mask = tableSize - 1;
for (int entryIndex = 0; entryIndex < n; entryIndex++) {
Entry entry = entryArray[entryIndex];
K key = entry.getKey();
V value = entry.getValue();
checkEntryNotNull(key, value);
int tableIndex = Hashing.smear(key.hashCode()) & mask;
@Nullable ImmutableMapEntry existing = table[tableIndex];
// prepend, not append, so the entries can be immutable
ImmutableMapEntry newEntry =
(existing == null)
? makeImmutable(entry, key, value)
: new NonTerminalImmutableMapEntry(key, value, existing);
table[tableIndex] = newEntry;
entries[entryIndex] = newEntry;
int bucketSize = checkNoConflictInKeyBucket(key, newEntry, existing);
if (bucketSize > MAX_HASH_BUCKET_LENGTH) {
// probable hash flooding attack, fall back to j.u.HM based implementation and use its
// implementation of hash flooding protection
return JdkBackedImmutableMap.create(n, entryArray);
}
}
return new RegularImmutableMap<>(entries, table, mask);
}
/** Makes an entry usable internally by a new ImmutableMap without rereading its contents. */
static ImmutableMapEntry makeImmutable(Entry entry, K key, V value) {
boolean reusable =
entry instanceof ImmutableMapEntry && ((ImmutableMapEntry) entry).isReusable();
return reusable ? (ImmutableMapEntry) entry : new ImmutableMapEntry(key, value);
}
/** Makes an entry usable internally by a new ImmutableMap. */
static ImmutableMapEntry makeImmutable(Entry entry) {
return makeImmutable(entry, entry.getKey(), entry.getValue());
}
private RegularImmutableMap(Entry[] entries, ImmutableMapEntry[] table, int mask) {
this.entries = entries;
this.table = table;
this.mask = mask;
}
/**
* @return number of entries in this bucket
* @throws IllegalArgumentException if another entry in the bucket has the same key
*/
@CanIgnoreReturnValue
static int checkNoConflictInKeyBucket(
Object key, Entry entry, @Nullable ImmutableMapEntry keyBucketHead) {
int bucketSize = 0;
for (; keyBucketHead != null; keyBucketHead = keyBucketHead.getNextInKeyBucket()) {
checkNoConflict(!key.equals(keyBucketHead.getKey()), "key", entry, keyBucketHead);
bucketSize++;
}
return bucketSize;
}
@Override
public V get(@Nullable Object key) {
return get(key, table, mask);
}
static @Nullable V get(
@Nullable Object key, ImmutableMapEntry @Nullable [] keyTable, int mask) {
if (key == null || keyTable == null) {
return null;
}
int index = Hashing.smear(key.hashCode()) & mask;
for (ImmutableMapEntry entry = keyTable[index];
entry != null;
entry = entry.getNextInKeyBucket()) {
Object candidateKey = entry.getKey();
/*
* Assume that equals uses the == optimization when appropriate, and that
* it would check hash codes as an optimization when appropriate. If we
* did these things, it would just make things worse for the most
* performance-conscious users.
*/
if (key.equals(candidateKey)) {
return entry.getValue();
}
}
return null;
}
@Override
public void forEach(BiConsumer action) {
checkNotNull(action);
for (Entry entry : entries) {
action.accept(entry.getKey(), entry.getValue());
}
}
@Override
public int size() {
return entries.length;
}
@Override
boolean isPartialView() {
return false;
}
@Override
ImmutableSet> createEntrySet() {
return new ImmutableMapEntrySet.RegularEntrySet<>(this, entries);
}
@Override
ImmutableSet createKeySet() {
return new KeySet<>(this);
}
@GwtCompatible(emulated = true)
private static final class KeySet extends IndexedImmutableSet {
private final RegularImmutableMap map;
KeySet(RegularImmutableMap map) {
this.map = map;
}
@Override
K get(int index) {
return map.entries[index].getKey();
}
@Override
public boolean contains(Object object) {
return map.containsKey(object);
}
@Override
boolean isPartialView() {
return true;
}
@Override
public int size() {
return map.size();
}
@GwtIncompatible // serialization
@Override
Object writeReplace() {
return new SerializedForm(map);
}
@GwtIncompatible // serialization
private static class SerializedForm implements Serializable {
final ImmutableMap map;
SerializedForm(ImmutableMap map) {
this.map = map;
}
Object readResolve() {
return map.keySet();
}
private static final long serialVersionUID = 0;
}
}
@Override
ImmutableCollection createValues() {
return new Values<>(this);
}
@GwtCompatible(emulated = true)
private static final class Values extends ImmutableList {
final RegularImmutableMap map;
Values(RegularImmutableMap map) {
this.map = map;
}
@Override
public V get(int index) {
return map.entries[index].getValue();
}
@Override
public int size() {
return map.size();
}
@Override
boolean isPartialView() {
return true;
}
@GwtIncompatible // serialization
@Override
Object writeReplace() {
return new SerializedForm(map);
}
@GwtIncompatible // serialization
private static class SerializedForm implements Serializable {
final ImmutableMap map;
SerializedForm(ImmutableMap map) {
this.map = map;
}
Object readResolve() {
return map.values();
}
private static final long serialVersionUID = 0;
}
}
// This class is never actually serialized directly, but we have to make the
// warning go away (and suppressing would suppress for all nested classes too)
private static final long serialVersionUID = 0;
}