Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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 org.testifyproject.guava.common.collect;
import static org.testifyproject.guava.common.base.Preconditions.checkNotNull;
import static org.testifyproject.guava.common.base.Preconditions.checkPositionIndex;
import static org.testifyproject.guava.common.collect.CollectPreconditions.checkEntryNotNull;
import static org.testifyproject.guava.common.collect.ImmutableMapEntry.createEntryArray;
import org.testifyproject.guava.common.annotations.GwtCompatible;
import org.testifyproject.guava.common.annotations.GwtIncompatible;
import org.testifyproject.guava.common.annotations.VisibleForTesting;
import org.testifyproject.guava.common.collect.ImmutableMapEntry.NonTerminalImmutableMapEntry;
import org.testifyproject.guava.j2objc.annotations.Weak;
import java.io.Serializable;
import java.util.function.BiConsumer;
import javax.annotation.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);
// 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 RegularImmutableMap fromEntries(Entry... entries) {
return fromEntryArray(entries.length, entries);
}
/**
* Creates a RegularImmutableMap 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 RegularImmutableMap 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;
if (existing == null) {
boolean reusable =
entry instanceof ImmutableMapEntry && ((ImmutableMapEntry) entry).isReusable();
newEntry =
reusable ? (ImmutableMapEntry) entry : new ImmutableMapEntry(key, value);
} else {
newEntry = new NonTerminalImmutableMapEntry<>(key, value, existing);
}
table[tableIndex] = newEntry;
entries[entryIndex] = newEntry;
checkNoConflictInKeyBucket(key, newEntry, existing);
}
return new RegularImmutableMap<>(entries, table, mask);
}
private RegularImmutableMap(Entry[] entries, ImmutableMapEntry[] table, int mask) {
this.entries = entries;
this.table = table;
this.mask = mask;
}
static void checkNoConflictInKeyBucket(
Object key, Entry entry, @Nullable ImmutableMapEntry keyBucketHead) {
for (; keyBucketHead != null; keyBucketHead = keyBucketHead.getNextInKeyBucket()) {
checkNoConflict(!key.equals(keyBucketHead.getKey()), "key", entry, keyBucketHead);
}
}
/**
* 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.
*/
private static final double MAX_LOAD_FACTOR = 1.2;
@Override
public V get(@Nullable Object key) {
return get(key, table, mask);
}
@Nullable
static V get(@Nullable Object key, @Nullable ImmutableMapEntry[] 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 ImmutableSet.Indexed {
@Weak 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 {
@Weak 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;
}
