mirror of
https://github.com/Eaglercraft-TeaVM-Fork/eagler-teavm.git
synced 2024-12-22 16:14:10 -08:00
Add IdentityHashMap, improve distribution of identityHashCode
Add IdentityHashMap, improve distribution of identityHashCode
This commit is contained in:
parent
ff07b28bee
commit
c11b868c0b
|
@ -0,0 +1,621 @@
|
||||||
|
/*
|
||||||
|
* Copyright 2014 Alexey Andreev.
|
||||||
|
*
|
||||||
|
* 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.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||||
|
* contributor license agreements. See the NOTICE file distributed with
|
||||||
|
* this work for additional information regarding copyright ownership.
|
||||||
|
* The ASF licenses this file to You 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.teavm.classlib.java.util;
|
||||||
|
|
||||||
|
import java.util.Arrays;
|
||||||
|
import java.util.ConcurrentModificationException;
|
||||||
|
import org.teavm.classlib.java.io.TSerializable;
|
||||||
|
import org.teavm.classlib.java.lang.TCloneNotSupportedException;
|
||||||
|
import org.teavm.classlib.java.lang.TCloneable;
|
||||||
|
import org.teavm.classlib.java.lang.TIllegalArgumentException;
|
||||||
|
import org.teavm.classlib.java.lang.TIllegalStateException;
|
||||||
|
import org.teavm.classlib.java.lang.TObject;
|
||||||
|
import org.teavm.interop.Rename;
|
||||||
|
|
||||||
|
public class TIdentityHashMap<K, V> extends TAbstractMap<K, V> implements TCloneable, TSerializable {
|
||||||
|
transient int elementCount;
|
||||||
|
transient HashEntry<K, V>[] elementData;
|
||||||
|
transient int modCount;
|
||||||
|
private static final int DEFAULT_SIZE = 16;
|
||||||
|
final float loadFactor;
|
||||||
|
int threshold;
|
||||||
|
|
||||||
|
static class HashEntry<K, V> extends TMapEntry<K, V> {
|
||||||
|
final int origKeyHash;
|
||||||
|
|
||||||
|
HashEntry<K, V> next;
|
||||||
|
|
||||||
|
HashEntry(K theKey, int hash) {
|
||||||
|
super(theKey, null);
|
||||||
|
this.origKeyHash = hash;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashEntry(K theKey, V theValue) {
|
||||||
|
super(theKey, theValue);
|
||||||
|
origKeyHash = theKey == null ? 0 : computeHashCode(theKey);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
@SuppressWarnings("unchecked")
|
||||||
|
public Object clone() {
|
||||||
|
HashEntry<K, V> entry = (HashEntry<K, V>) super.clone();
|
||||||
|
if (next != null) {
|
||||||
|
entry.next = (HashEntry<K, V>) next.clone();
|
||||||
|
}
|
||||||
|
return entry;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static class AbstractMapIterator<K, V> {
|
||||||
|
private int position;
|
||||||
|
int expectedModCount;
|
||||||
|
HashEntry<K, V> futureEntry;
|
||||||
|
HashEntry<K, V> currentEntry;
|
||||||
|
HashEntry<K, V> prevEntry;
|
||||||
|
|
||||||
|
final TIdentityHashMap<K, V> associatedMap;
|
||||||
|
|
||||||
|
AbstractMapIterator(TIdentityHashMap<K, V> hm) {
|
||||||
|
associatedMap = hm;
|
||||||
|
expectedModCount = hm.modCount;
|
||||||
|
futureEntry = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean hasNext() {
|
||||||
|
if (futureEntry != null) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
while (position < associatedMap.elementData.length) {
|
||||||
|
if (associatedMap.elementData[position] == null) {
|
||||||
|
position++;
|
||||||
|
} else {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
final void checkConcurrentMod() throws ConcurrentModificationException {
|
||||||
|
if (expectedModCount != associatedMap.modCount) {
|
||||||
|
throw new TConcurrentModificationException();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
final void makeNext() {
|
||||||
|
checkConcurrentMod();
|
||||||
|
if (!hasNext()) {
|
||||||
|
throw new TNoSuchElementException();
|
||||||
|
}
|
||||||
|
if (futureEntry == null) {
|
||||||
|
currentEntry = associatedMap.elementData[position++];
|
||||||
|
futureEntry = currentEntry.next;
|
||||||
|
prevEntry = null;
|
||||||
|
} else {
|
||||||
|
if (currentEntry != null) {
|
||||||
|
prevEntry = currentEntry;
|
||||||
|
}
|
||||||
|
currentEntry = futureEntry;
|
||||||
|
futureEntry = futureEntry.next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public final void remove() {
|
||||||
|
checkConcurrentMod();
|
||||||
|
if (currentEntry == null) {
|
||||||
|
throw new TIllegalStateException();
|
||||||
|
}
|
||||||
|
if (prevEntry == null) {
|
||||||
|
int index = currentEntry.origKeyHash & (associatedMap.elementData.length - 1);
|
||||||
|
associatedMap.elementData[index] = associatedMap.elementData[index].next;
|
||||||
|
} else {
|
||||||
|
prevEntry.next = currentEntry.next;
|
||||||
|
}
|
||||||
|
currentEntry = null;
|
||||||
|
expectedModCount++;
|
||||||
|
associatedMap.modCount++;
|
||||||
|
associatedMap.elementCount--;
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
private static class EntryIterator<K, V> extends AbstractMapIterator<K, V>
|
||||||
|
implements TIterator<Entry<K, V>> {
|
||||||
|
EntryIterator(TIdentityHashMap<K, V> map) {
|
||||||
|
super(map);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Entry<K, V> next() {
|
||||||
|
makeNext();
|
||||||
|
return currentEntry;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static class KeyIterator<K, V> extends AbstractMapIterator<K, V> implements TIterator<K> {
|
||||||
|
KeyIterator(TIdentityHashMap<K, V> map) {
|
||||||
|
super(map);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public K next() {
|
||||||
|
makeNext();
|
||||||
|
return currentEntry.key;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static class ValueIterator<K, V> extends AbstractMapIterator<K, V> implements TIterator<V> {
|
||||||
|
ValueIterator(TIdentityHashMap<K, V> map) {
|
||||||
|
super(map);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public V next() {
|
||||||
|
makeNext();
|
||||||
|
return currentEntry.value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static class HashMapEntrySet<K, V> extends TAbstractSet<Entry<K, V>> {
|
||||||
|
private final TIdentityHashMap<K, V> associatedMap;
|
||||||
|
|
||||||
|
public HashMapEntrySet(TIdentityHashMap<K, V> hm) {
|
||||||
|
associatedMap = hm;
|
||||||
|
}
|
||||||
|
|
||||||
|
TIdentityHashMap<K, V> hashMap() {
|
||||||
|
return associatedMap;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int size() {
|
||||||
|
return associatedMap.elementCount;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void clear() {
|
||||||
|
associatedMap.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean remove(Object object) {
|
||||||
|
if (object instanceof TMap.Entry) {
|
||||||
|
Entry<?, ?> oEntry = (Entry<?, ?>) object;
|
||||||
|
Entry<K, V> entry = associatedMap.getEntry(oEntry.getKey());
|
||||||
|
if (valuesEq(entry, oEntry)) {
|
||||||
|
associatedMap.removeEntry(entry);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean contains(Object object) {
|
||||||
|
if (object instanceof TMap.Entry) {
|
||||||
|
Entry<?, ?> oEntry = (Entry<?, ?>) object;
|
||||||
|
Entry<K, V> entry = associatedMap.getEntry(oEntry.getKey());
|
||||||
|
return valuesEq(entry, oEntry);
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static boolean valuesEq(Entry<?, ?> entry, Entry<?, ?> oEntry) {
|
||||||
|
return entry != null
|
||||||
|
&& (entry.getValue() == null
|
||||||
|
? oEntry.getValue() == null
|
||||||
|
: areSameValues(entry.getValue(), oEntry.getValue()));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public TIterator<Entry<K, V>> iterator() {
|
||||||
|
return new EntryIterator<>(associatedMap);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@SuppressWarnings("unchecked")
|
||||||
|
HashEntry<K, V>[] newElementArray(int s) {
|
||||||
|
return new HashEntry[s];
|
||||||
|
}
|
||||||
|
|
||||||
|
public TIdentityHashMap() {
|
||||||
|
this(DEFAULT_SIZE);
|
||||||
|
}
|
||||||
|
|
||||||
|
public TIdentityHashMap(int capacity) {
|
||||||
|
this(capacity, 0.75f); // default load factor of 0.75
|
||||||
|
}
|
||||||
|
|
||||||
|
private static int calculateCapacity(int x) {
|
||||||
|
if (x >= 1 << 30) {
|
||||||
|
return 1 << 30;
|
||||||
|
}
|
||||||
|
if (x == 0) {
|
||||||
|
return 16;
|
||||||
|
}
|
||||||
|
x = x - 1;
|
||||||
|
x |= x >> 1;
|
||||||
|
x |= x >> 2;
|
||||||
|
x |= x >> 4;
|
||||||
|
x |= x >> 8;
|
||||||
|
x |= x >> 16;
|
||||||
|
return x + 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constructs a new {@code HashMap} instance with the specified capacity and
|
||||||
|
* load factor.
|
||||||
|
*
|
||||||
|
* @param capacity
|
||||||
|
* the initial capacity of this hash map.
|
||||||
|
* @param loadFactor
|
||||||
|
* the initial load factor.
|
||||||
|
* @throws IllegalArgumentException
|
||||||
|
* when the capacity is less than zero or the load factor is
|
||||||
|
* less or equal to zero.
|
||||||
|
*/
|
||||||
|
public TIdentityHashMap(int capacity, float loadFactor) {
|
||||||
|
if (capacity >= 0 && loadFactor > 0) {
|
||||||
|
capacity = calculateCapacity(capacity);
|
||||||
|
elementCount = 0;
|
||||||
|
elementData = newElementArray(capacity);
|
||||||
|
this.loadFactor = loadFactor;
|
||||||
|
computeThreshold();
|
||||||
|
} else {
|
||||||
|
throw new TIllegalArgumentException();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public TIdentityHashMap(TMap<? extends K, ? extends V> map) {
|
||||||
|
this(calculateCapacity(map.size()));
|
||||||
|
putAllImpl(map);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void clear() {
|
||||||
|
if (elementCount > 0) {
|
||||||
|
elementCount = 0;
|
||||||
|
Arrays.fill(elementData, null);
|
||||||
|
modCount++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Rename("clone")
|
||||||
|
@SuppressWarnings("unchecked")
|
||||||
|
public TObject clone0() {
|
||||||
|
try {
|
||||||
|
TIdentityHashMap<K, V> map = (TIdentityHashMap<K, V>) super.clone();
|
||||||
|
map.elementCount = 0;
|
||||||
|
map.elementData = newElementArray(elementData.length);
|
||||||
|
map.putAll(this);
|
||||||
|
|
||||||
|
return map;
|
||||||
|
} catch (TCloneNotSupportedException e) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void computeThreshold() {
|
||||||
|
threshold = (int) (elementData.length * loadFactor);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean containsKey(Object key) {
|
||||||
|
HashEntry<K, V> m = getEntry(key);
|
||||||
|
return m != null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean containsValue(Object value) {
|
||||||
|
if (value != null) {
|
||||||
|
for (int i = 0; i < elementData.length; i++) {
|
||||||
|
HashEntry<K, V> entry = elementData[i];
|
||||||
|
while (entry != null) {
|
||||||
|
if (areSameValues(value, entry.value)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
entry = entry.next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
for (int i = 0; i < elementData.length; i++) {
|
||||||
|
HashEntry<K, V> entry = elementData[i];
|
||||||
|
while (entry != null) {
|
||||||
|
if (entry.value == null) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
entry = entry.next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public TSet<Entry<K, V>> entrySet() {
|
||||||
|
return new HashMapEntrySet<>(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public V get(Object key) {
|
||||||
|
HashEntry<K, V> m = getEntry(key);
|
||||||
|
if (m != null) {
|
||||||
|
return m.value;
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
final HashEntry<K, V> getEntry(Object key) {
|
||||||
|
HashEntry<K, V> m;
|
||||||
|
if (key == null) {
|
||||||
|
m = findNullKeyEntry();
|
||||||
|
} else {
|
||||||
|
int hash = computeHashCode(key);
|
||||||
|
int index = hash & (elementData.length - 1);
|
||||||
|
m = findNonNullKeyEntry(key, index, hash);
|
||||||
|
}
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
|
||||||
|
final HashEntry<K, V> findNonNullKeyEntry(Object key, int index, int keyHash) {
|
||||||
|
HashEntry<K, V> m = elementData[index];
|
||||||
|
while (m != null
|
||||||
|
&& (m.origKeyHash != keyHash || !areSameKeys(key, m.key))) {
|
||||||
|
m = m.next;
|
||||||
|
}
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
|
||||||
|
final HashEntry<K, V> findNullKeyEntry() {
|
||||||
|
HashEntry<K, V> m = elementData[0];
|
||||||
|
while (m != null && m.key != null) {
|
||||||
|
m = m.next;
|
||||||
|
}
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean isEmpty() {
|
||||||
|
return elementCount == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public TSet<K> keySet() {
|
||||||
|
if (cachedKeySet == null) {
|
||||||
|
cachedKeySet = new TAbstractSet<K>() {
|
||||||
|
@Override public boolean contains(Object object) {
|
||||||
|
return containsKey(object);
|
||||||
|
}
|
||||||
|
@Override public int size() {
|
||||||
|
return TIdentityHashMap.this.size();
|
||||||
|
}
|
||||||
|
@Override public void clear() {
|
||||||
|
TIdentityHashMap.this.clear();
|
||||||
|
}
|
||||||
|
@Override public boolean remove(Object key) {
|
||||||
|
HashEntry<K, V> entry = TIdentityHashMap.this.removeEntry(key);
|
||||||
|
return entry != null;
|
||||||
|
}
|
||||||
|
@Override public TIterator<K> iterator() {
|
||||||
|
return new KeyIterator<>(TIdentityHashMap.this);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
return cachedKeySet;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public V put(K key, V value) {
|
||||||
|
return putImpl(key, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
V putImpl(K key, V value) {
|
||||||
|
HashEntry<K, V> entry;
|
||||||
|
if (key == null) {
|
||||||
|
entry = findNullKeyEntry();
|
||||||
|
if (entry == null) {
|
||||||
|
modCount++;
|
||||||
|
entry = createHashedEntry(null, 0, 0);
|
||||||
|
if (++elementCount > threshold) {
|
||||||
|
rehash();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
int hash = computeHashCode(key);
|
||||||
|
int index = hash & (elementData.length - 1);
|
||||||
|
entry = findNonNullKeyEntry(key, index, hash);
|
||||||
|
if (entry == null) {
|
||||||
|
modCount++;
|
||||||
|
entry = createHashedEntry(key, index, hash);
|
||||||
|
if (++elementCount > threshold) {
|
||||||
|
rehash();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
V result = entry.value;
|
||||||
|
entry.value = value;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashEntry<K, V> createEntry(K key, int index, V value) {
|
||||||
|
HashEntry<K, V> entry = new HashEntry<>(key, value);
|
||||||
|
entry.next = elementData[index];
|
||||||
|
elementData[index] = entry;
|
||||||
|
return entry;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashEntry<K, V> createHashedEntry(K key, int index, int hash) {
|
||||||
|
HashEntry<K, V> entry = new HashEntry<>(key, hash);
|
||||||
|
entry.next = elementData[index];
|
||||||
|
elementData[index] = entry;
|
||||||
|
return entry;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void putAll(TMap<? extends K, ? extends V> map) {
|
||||||
|
if (!map.isEmpty()) {
|
||||||
|
putAllImpl(map);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void putAllImpl(TMap<? extends K, ? extends V> map) {
|
||||||
|
int capacity = elementCount + map.size();
|
||||||
|
if (capacity > threshold) {
|
||||||
|
rehash(capacity);
|
||||||
|
}
|
||||||
|
for (TIterator<? extends Entry<? extends K, ? extends V>> iter = map.entrySet().iterator();
|
||||||
|
iter.hasNext();) {
|
||||||
|
Entry<? extends K, ? extends V> entry = iter.next();
|
||||||
|
putImpl(entry.getKey(), entry.getValue());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void rehash(int capacity) {
|
||||||
|
int length = calculateCapacity(capacity == 0 ? 1 : capacity << 1);
|
||||||
|
|
||||||
|
HashEntry<K, V>[] newData = newElementArray(length);
|
||||||
|
for (int i = 0; i < elementData.length; i++) {
|
||||||
|
HashEntry<K, V> entry = elementData[i];
|
||||||
|
elementData[i] = null;
|
||||||
|
while (entry != null) {
|
||||||
|
int index = entry.origKeyHash & (length - 1);
|
||||||
|
HashEntry<K, V> next = entry.next;
|
||||||
|
entry.next = newData[index];
|
||||||
|
newData[index] = entry;
|
||||||
|
entry = next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
elementData = newData;
|
||||||
|
computeThreshold();
|
||||||
|
}
|
||||||
|
|
||||||
|
void rehash() {
|
||||||
|
rehash(elementData.length);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public V remove(Object key) {
|
||||||
|
HashEntry<K, V> entry = removeEntry(key);
|
||||||
|
if (entry != null) {
|
||||||
|
return entry.value;
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
final void removeEntry(HashEntry<K, V> entry) {
|
||||||
|
int index = entry.origKeyHash & (elementData.length - 1);
|
||||||
|
HashEntry<K, V> m = elementData[index];
|
||||||
|
if (m == entry) {
|
||||||
|
elementData[index] = entry.next;
|
||||||
|
} else {
|
||||||
|
while (m.next != entry) {
|
||||||
|
m = m.next;
|
||||||
|
}
|
||||||
|
m.next = entry.next;
|
||||||
|
|
||||||
|
}
|
||||||
|
modCount++;
|
||||||
|
elementCount--;
|
||||||
|
}
|
||||||
|
|
||||||
|
final HashEntry<K, V> removeEntry(Object key) {
|
||||||
|
int index = 0;
|
||||||
|
HashEntry<K, V> entry;
|
||||||
|
HashEntry<K, V> last = null;
|
||||||
|
if (key != null) {
|
||||||
|
int hash = computeHashCode(key);
|
||||||
|
index = hash & (elementData.length - 1);
|
||||||
|
entry = elementData[index];
|
||||||
|
while (entry != null && !(entry.origKeyHash == hash && areSameKeys(key, entry.key))) {
|
||||||
|
last = entry;
|
||||||
|
entry = entry.next;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
entry = elementData[0];
|
||||||
|
while (entry != null && entry.key != null) {
|
||||||
|
last = entry;
|
||||||
|
entry = entry.next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (entry == null) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
if (last == null) {
|
||||||
|
elementData[index] = entry.next;
|
||||||
|
} else {
|
||||||
|
last.next = entry.next;
|
||||||
|
}
|
||||||
|
modCount++;
|
||||||
|
elementCount--;
|
||||||
|
return entry;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int size() {
|
||||||
|
return elementCount;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public TCollection<V> values() {
|
||||||
|
if (cachedValues == null) {
|
||||||
|
cachedValues = new TAbstractCollection<V>() {
|
||||||
|
@Override public boolean contains(Object object) {
|
||||||
|
return containsValue(object);
|
||||||
|
}
|
||||||
|
@Override public int size() {
|
||||||
|
return TIdentityHashMap.this.size();
|
||||||
|
}
|
||||||
|
@Override public void clear() {
|
||||||
|
TIdentityHashMap.this.clear();
|
||||||
|
}
|
||||||
|
@Override public TIterator<V> iterator() {
|
||||||
|
return new ValueIterator<>(TIdentityHashMap.this);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
return cachedValues;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int computeHashCode(Object key) {
|
||||||
|
return System.identityHashCode(key);
|
||||||
|
}
|
||||||
|
|
||||||
|
static boolean areSameKeys(Object key1, Object key2) {
|
||||||
|
return key1 == key2;
|
||||||
|
}
|
||||||
|
|
||||||
|
static boolean areSameValues(Object value1, Object value2) {
|
||||||
|
return value1 == value2;
|
||||||
|
}
|
||||||
|
}
|
|
@ -15,15 +15,14 @@
|
||||||
*/
|
*/
|
||||||
"use strict";
|
"use strict";
|
||||||
var $rt_global = this;
|
var $rt_global = this;
|
||||||
var $rt_lastObjectId = 1;
|
var $rt_seed = 2463534242;
|
||||||
function $rt_nextId() {
|
function $rt_nextId() {
|
||||||
var current = $rt_lastObjectId;
|
var x = $rt_seed;
|
||||||
var next = (current + 1) | 0;
|
x ^= x << 13;
|
||||||
if (next === 0) {
|
x ^= x >> 17;
|
||||||
next = (next + 1) | 0;
|
x ^= x << 5;
|
||||||
}
|
$rt_seed = x;
|
||||||
$rt_lastObjectId = next;
|
return x;
|
||||||
return current;
|
|
||||||
}
|
}
|
||||||
function $rt_compare(a, b) {
|
function $rt_compare(a, b) {
|
||||||
return a > b ? 1 : a < b ? -1 : 0;
|
return a > b ? 1 : a < b ? -1 : 0;
|
||||||
|
|
|
@ -0,0 +1,113 @@
|
||||||
|
/*
|
||||||
|
* Copyright 2014 Alexey Andreev.
|
||||||
|
*
|
||||||
|
* 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||||
|
* contributor license agreements. See the NOTICE file distributed with
|
||||||
|
* this work for additional information regarding copyright ownership.
|
||||||
|
* The ASF licenses this file to You 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.teavm.classlib.java.util;
|
||||||
|
|
||||||
|
import static org.junit.Assert.assertEquals;
|
||||||
|
import java.util.IdentityHashMap;
|
||||||
|
import java.util.Map;
|
||||||
|
import java.util.Objects;
|
||||||
|
import org.junit.Test;
|
||||||
|
import org.junit.runner.RunWith;
|
||||||
|
import org.teavm.junit.TeaVMTestRunner;
|
||||||
|
|
||||||
|
@RunWith(TeaVMTestRunner.class)
|
||||||
|
public class IdentityHashMapTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
public void sameObjectOnce() {
|
||||||
|
Map<Object, Object> m = new IdentityHashMap<>();
|
||||||
|
Object key = new Object();
|
||||||
|
m.put(key, "val1");
|
||||||
|
m.put(key, "val2");
|
||||||
|
assertEquals(1, m.keySet().size());
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
public void twoObjectsTwice() {
|
||||||
|
Map<Object, Object> m = new IdentityHashMap<>();
|
||||||
|
Object key1 = new Object();
|
||||||
|
Object key2 = new Object();
|
||||||
|
m.put(key1, "val1");
|
||||||
|
m.put(key2, "val2");
|
||||||
|
assertEquals(2, m.size());
|
||||||
|
assertEquals("val1", m.get(key1));
|
||||||
|
assertEquals("val2", m.get(key2));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
public void twoObjectsWithSameHashCode() {
|
||||||
|
Map<A, Object> m = new IdentityHashMap<>();
|
||||||
|
A key1 = new A("ciao");
|
||||||
|
A key2 = new A("ciao");
|
||||||
|
m.put(key1, "val1");
|
||||||
|
m.put(key2, "val2");
|
||||||
|
assertEquals(2, m.size());
|
||||||
|
assertEquals("val1", m.get(key1));
|
||||||
|
assertEquals("val2", m.get(key2));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
public void nullKeyAllowed() {
|
||||||
|
Map<String, String> m = new IdentityHashMap<>();
|
||||||
|
m.put(null, "val1");
|
||||||
|
m.put(null, "val2");
|
||||||
|
assertEquals(1, m.size());
|
||||||
|
assertEquals("val2", m.get(null));
|
||||||
|
}
|
||||||
|
|
||||||
|
static class A {
|
||||||
|
public A(String b) {
|
||||||
|
this.b = b;
|
||||||
|
}
|
||||||
|
|
||||||
|
private String b;
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public boolean equals(Object o) {
|
||||||
|
if (this == o) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
if (o == null || getClass() != o.getClass()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
A a = (A) o;
|
||||||
|
return Objects.equals(b, a.b);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int hashCode() {
|
||||||
|
return Objects.hash(b);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
Loading…
Reference in New Issue
Block a user