com.google.common.collect.RegularImmutableBiMap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of guava Show documentation
Show all versions of guava Show documentation
Guava is a suite of core and expanded libraries that include
utility classes, google's collections, io classes, and much
much more.
/*
* 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;
}
}