com.google.common.collect.RegularImmutableBiMap Maven / Gradle / Ivy
Go to download
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 static com.google.common.collect.RegularImmutableMap.checkNoConflictInKeyBucket;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMapEntry.NonTerminalImmutableBiMapEntry;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.concurrent.LazyInit;
import com.google.j2objc.annotations.RetainedWith;
import java.io.Serializable;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import org.checkerframework.checker.nullness.qual.Nullable;
/**
* Bimap with zero or more mappings.
*
* @author Louis Wasserman
*/
@GwtCompatible(serializable = true, emulated = true)
@SuppressWarnings("serial") // uses writeReplace(), not default serialization
class RegularImmutableBiMap extends ImmutableBiMap {
static final RegularImmutableBiMap EMPTY =
new RegularImmutableBiMap<>(
null, null, (Entry[]) ImmutableMap.EMPTY_ENTRY_ARRAY, 0, 0);
static final double MAX_LOAD_FACTOR = 1.2;
private final transient ImmutableMapEntry[] keyTable;
private final transient ImmutableMapEntry[] valueTable;
@VisibleForTesting final transient Entry[] entries;
private final transient int mask;
private final transient int hashCode;
static ImmutableBiMap fromEntries(Entry... entries) {
return fromEntryArray(entries.length, entries);
}
static ImmutableBiMap fromEntryArray(int n, Entry[] entryArray) {
checkPositionIndex(n, entryArray.length);
int tableSize = Hashing.closedTableSize(n, MAX_LOAD_FACTOR);
int mask = tableSize - 1;
ImmutableMapEntry[] keyTable = createEntryArray(tableSize);
ImmutableMapEntry[] valueTable = createEntryArray(tableSize);
Entry[] entries;
if (n == entryArray.length) {
entries = entryArray;
} else {
entries = createEntryArray(n);
}
int hashCode = 0;
for (int i = 0; i < n; i++) {
@SuppressWarnings("unchecked")
Entry entry = entryArray[i];
K key = entry.getKey();
V value = entry.getValue();
checkEntryNotNull(key, value);
int keyHash = key.hashCode();
int valueHash = value.hashCode();
int keyBucket = Hashing.smear(keyHash) & mask;
int valueBucket = Hashing.smear(valueHash) & mask;
ImmutableMapEntry nextInKeyBucket = keyTable[keyBucket];
int keyBucketLength = checkNoConflictInKeyBucket(key, entry, nextInKeyBucket);
ImmutableMapEntry nextInValueBucket = valueTable[valueBucket];
int valueBucketLength = checkNoConflictInValueBucket(value, entry, nextInValueBucket);
if (keyBucketLength > RegularImmutableMap.MAX_HASH_BUCKET_LENGTH
|| valueBucketLength > RegularImmutableMap.MAX_HASH_BUCKET_LENGTH) {
return JdkBackedImmutableBiMap.create(n, entryArray);
}
ImmutableMapEntry newEntry =
(nextInValueBucket == null && nextInKeyBucket == null)
? RegularImmutableMap.makeImmutable(entry, key, value)
: new NonTerminalImmutableBiMapEntry<>(
key, value, nextInKeyBucket, nextInValueBucket);
keyTable[keyBucket] = newEntry;
valueTable[valueBucket] = newEntry;
entries[i] = newEntry;
hashCode += keyHash ^ valueHash;
}
return new RegularImmutableBiMap<>(keyTable, valueTable, entries, mask, hashCode);
}
private RegularImmutableBiMap(
ImmutableMapEntry[] keyTable,
ImmutableMapEntry[] valueTable,
Entry[] entries,
int mask,
int hashCode) {
this.keyTable = keyTable;
this.valueTable = valueTable;
this.entries = entries;
this.mask = mask;
this.hashCode = hashCode;
}
// checkNoConflictInKeyBucket is static imported from RegularImmutableMap
/**
* @return number of entries in this bucket
* @throws IllegalArgumentException if another entry in the bucket has the same key
*/
@CanIgnoreReturnValue
private static int checkNoConflictInValueBucket(
Object value, Entry entry, @Nullable ImmutableMapEntry valueBucketHead) {
int bucketSize = 0;
for (; valueBucketHead != null; valueBucketHead = valueBucketHead.getNextInValueBucket()) {
checkNoConflict(!value.equals(valueBucketHead.getValue()), "value", entry, valueBucketHead);
bucketSize++;
}
return bucketSize;
}
@Override
public @Nullable V get(@Nullable Object key) {
return (keyTable == null) ? null : RegularImmutableMap.get(key, keyTable, mask);
}
@Override
ImmutableSet> createEntrySet() {
return isEmpty()
? ImmutableSet.>of()
: new ImmutableMapEntrySet.RegularEntrySet(this, entries);
}
@Override
ImmutableSet createKeySet() {
return new ImmutableMapKeySet<>(this);
}
@Override
public void forEach(BiConsumer action) {
checkNotNull(action);
for (Entry entry : entries) {
action.accept(entry.getKey(), entry.getValue());
}
}
@Override
boolean isHashCodeFast() {
return true;
}
@Override
public int hashCode() {
return hashCode;
}
@Override
boolean isPartialView() {
return false;
}
@Override
public int size() {
return entries.length;
}
@LazyInit @RetainedWith private transient ImmutableBiMap inverse;
@Override
public ImmutableBiMap inverse() {
if (isEmpty()) {
return ImmutableBiMap.of();
}
ImmutableBiMap result = inverse;
return (result == null) ? inverse = new Inverse() : result;
}
private final class Inverse extends ImmutableBiMap {
@Override
public int size() {
return inverse().size();
}
@Override
public ImmutableBiMap inverse() {
return RegularImmutableBiMap.this;
}
@Override
public void forEach(BiConsumer action) {
checkNotNull(action);
RegularImmutableBiMap.this.forEach((k, v) -> action.accept(v, k));
}
@Override
public K get(@Nullable Object value) {
if (value == null || valueTable == null) {
return null;
}
int bucket = Hashing.smear(value.hashCode()) & mask;
for (ImmutableMapEntry entry = valueTable[bucket];
entry != null;
entry = entry.getNextInValueBucket()) {
if (value.equals(entry.getValue())) {
return entry.getKey();
}
}
return null;
}
@Override
ImmutableSet createKeySet() {
return new ImmutableMapKeySet<>(this);
}
@Override
ImmutableSet> createEntrySet() {
return new InverseEntrySet();
}
final class InverseEntrySet extends ImmutableMapEntrySet {
@Override
ImmutableMap map() {
return Inverse.this;
}
@Override
boolean isHashCodeFast() {
return true;
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public UnmodifiableIterator> iterator() {
return asList().iterator();
}
@Override
public void forEach(Consumer> action) {
asList().forEach(action);
}
@Override
ImmutableList> createAsList() {
return new ImmutableAsList>() {
@Override
public Entry get(int index) {
Entry entry = entries[index];
return Maps.immutableEntry(entry.getValue(), entry.getKey());
}
@Override
ImmutableCollection> delegateCollection() {
return InverseEntrySet.this;
}
};
}
}
@Override
boolean isPartialView() {
return false;
}
@Override
Object writeReplace() {
return new InverseSerializedForm<>(RegularImmutableBiMap.this);
}
}
private static class InverseSerializedForm implements Serializable {
private final ImmutableBiMap forward;
InverseSerializedForm(ImmutableBiMap forward) {
this.forward = forward;
}
Object readResolve() {
return forward.inverse();
}
private static final long serialVersionUID = 1;
}
}