package com.carrotsearch.hppc;
import java.util.*;
import com.carrotsearch.hppc.cursors.*;
import com.carrotsearch.hppc.predicates.*;
import com.carrotsearch.hppc.procedures.*;
import static com.carrotsearch.hppc.HashContainers.*;
import static com.carrotsearch.hppc.Containers.*;
@com.carrotsearch.hppc.Generated(
date = "2018-05-21T12:24:06+0200",
value = "KTypeVTypeHashMap.java")
public class ShortFloatHashMap
implements
ShortFloatMap,
Preallocable,
Cloneable
{
public short []
keys;
public float []
values;
protected int keyMixer;
protected int assigned;
protected int mask;
protected int resizeAt;
protected boolean hasEmptyKey;
protected double loadFactor;
protected HashOrderMixingStrategy orderMixer;
public ShortFloatHashMap() {
this(DEFAULT_EXPECTED_ELEMENTS);
}
public ShortFloatHashMap(int expectedElements) {
this(expectedElements, DEFAULT_LOAD_FACTOR);
}
public ShortFloatHashMap(int expectedElements, double loadFactor) {
this(expectedElements, loadFactor, HashOrderMixing.defaultStrategy());
}
public ShortFloatHashMap(int expectedElements, double loadFactor, HashOrderMixingStrategy orderMixer) {
this.orderMixer = orderMixer;
this.loadFactor = verifyLoadFactor(loadFactor);
ensureCapacity(expectedElements);
}
public ShortFloatHashMap(ShortFloatAssociativeContainer container) {
this(container.size());
putAll(container);
}
@Override
public float put(short key, float value) {
assert assigned < mask + 1;
final int mask = this.mask;
if (((key) == 0)) {
hasEmptyKey = true;
float previousValue = values[mask + 1];
values[mask + 1] = value;
return previousValue;
} else {
final short[] keys = this.keys;
int slot = hashKey(key) & mask;
short existing;
while (!((existing = keys[slot]) == 0)) {
if (((existing) == ( key))) {
final float previousValue = values[slot];
values[slot] = value;
return previousValue;
}
slot = (slot + 1) & mask;
}
if (assigned == resizeAt) {
allocateThenInsertThenRehash(slot, key, value);
} else {
keys[slot] = key;
values[slot] = value;
}
assigned++;
return 0f;
}
}
@Override
public int putAll(ShortFloatAssociativeContainer container) {
final int count = size();
for (ShortFloatCursor c : container) {
put(c.key, c.value);
}
return size() - count;
}
@Override
public int putAll(Iterable<? extends ShortFloatCursor> iterable){
final int count = size();
for (ShortFloatCursor c : iterable) {
put(c.key, c.value);
}
return size() - count;
}
public boolean putIfAbsent(short key, float value) {
int keyIndex = indexOf(key);
if (!indexExists(keyIndex)) {
indexInsert(keyIndex, key, value);
return true;
} else {
return false;
}
}
@Override
public float putOrAdd(short key, float putValue, float incrementValue) {
assert assigned < mask + 1;
int keyIndex = indexOf(key);
if (indexExists(keyIndex)) {
putValue = ((float) (( values[keyIndex]) + (incrementValue)));
indexReplace(keyIndex, putValue);
} else {
indexInsert(keyIndex, key, putValue);
}
return putValue;
}
@Override
public float addTo(short key, float incrementValue)
{
return putOrAdd(key, incrementValue, incrementValue);
}
@Override
public float remove(short key) {
final int mask = this.mask;
if (((key) == 0)) {
hasEmptyKey = false;
float previousValue = values[mask + 1];
values[mask + 1] = 0f;
return previousValue;
} else {
final short[] keys = this.keys;
int slot = hashKey(key) & mask;
short existing;
while (!((existing = keys[slot]) == 0)) {
if (((existing) == ( key))) {
final float previousValue = values[slot];
shiftConflictingKeys(slot);
return previousValue;
}
slot = (slot + 1) & mask;
}
return 0f;
}
}
@Override
public int removeAll(ShortContainer other) {
final int before = size();
if (other.size() >= size() &&
other instanceof ShortLookupContainer) {
if (hasEmptyKey) {
if (other.contains(((short) 0))) {
hasEmptyKey = false;
values[mask + 1] = 0f;
}
}
final short[] keys = this.keys;
for (int slot = 0, max = this.mask; slot <= max;) {
short existing;
if (!((existing = keys[slot]) == 0) && other.contains(existing)) {
shiftConflictingKeys(slot);
} else {
slot++;
}
}
} else {
for (ShortCursor c : other) {
this.remove( c.value);
}
}
return before - size();
}
@Override
public int removeAll(ShortFloatPredicate predicate) {
final int before = size();
final int mask = this.mask;
if (hasEmptyKey) {
if (predicate.apply(((short) 0), values[mask + 1])) {
hasEmptyKey = false;
values[mask + 1] = 0f;
}
}
final short[] keys = this.keys;
final float[] values = this.values;
for (int slot = 0; slot <= mask;) {
short existing;
if (!((existing = keys[slot]) == 0) &&
predicate.apply(existing, values[slot])) {
shiftConflictingKeys(slot);
} else {
slot++;
}
}
return before - size();
}
@Override
public int removeAll(ShortPredicate predicate) {
final int before = size();
if (hasEmptyKey) {
if (predicate.apply(((short) 0))) {
hasEmptyKey = false;
values[mask + 1] = 0f;
}
}
final short[] keys = this.keys;
for (int slot = 0, max = this.mask; slot <= max;) {
short existing;
if (!((existing = keys[slot]) == 0) &&
predicate.apply(existing)) {
shiftConflictingKeys(slot);
} else {
slot++;
}
}
return before - size();
}
@Override
public float get(short key) {
if (((key) == 0)) {
return hasEmptyKey ? values[mask + 1] : 0f;
} else {
final short[] keys = this.keys;
final int mask = this.mask;
int slot = hashKey(key) & mask;
short existing;
while (!((existing = keys[slot]) == 0)) {
if (((existing) == ( key))) {
return values[slot];
}
slot = (slot + 1) & mask;
}
return 0f;
}
}
@Override
public float getOrDefault(short key, float defaultValue) {
if (((key) == 0)) {
return hasEmptyKey ? values[mask + 1] : defaultValue;
} else {
final short[] keys = this.keys;
final int mask = this.mask;
int slot = hashKey(key) & mask;
short existing;
while (!((existing = keys[slot]) == 0)) {
if (((existing) == ( key))) {
return values[slot];
}
slot = (slot + 1) & mask;
}
return defaultValue;
}
}
@Override
public boolean containsKey(short key) {
if (((key) == 0)) {
return hasEmptyKey;
} else {
final short[] keys = this.keys;
final int mask = this.mask;
int slot = hashKey(key) & mask;
short existing;
while (!((existing = keys[slot]) == 0)) {
if (((existing) == ( key))) {
return true;
}
slot = (slot + 1) & mask;
}
return false;
}
}
@Override
public int indexOf(short key) {
final int mask = this.mask;
if (((key) == 0)) {
return hasEmptyKey ? mask + 1 : ~(mask + 1);
} else {
final short[] keys = this.keys;
int slot = hashKey(key) & mask;
short existing;
while (!((existing = keys[slot]) == 0)) {
if (((existing) == ( key))) {
return slot;
}
slot = (slot + 1) & mask;
}
return ~slot;
}
}
@Override
public boolean indexExists(int index) {
assert index < 0 ||
(index >= 0 && index <= mask) ||
(index == mask + 1 && hasEmptyKey);
return index >= 0;
}
@Override
public float indexGet(int index) {
assert index >= 0 : "The index must point at an existing key.";
assert index <= mask ||
(index == mask + 1 && hasEmptyKey);
return values[index];
}
@Override
public float indexReplace(int index, float newValue) {
assert index >= 0 : "The index must point at an existing key.";
assert index <= mask ||
(index == mask + 1 && hasEmptyKey);
float previousValue = values[index];
values[index] = newValue;
return previousValue;
}
@Override
public void indexInsert(int index, short key, float value) {
assert index < 0 : "The index must not point at an existing key.";
index = ~index;
if (((key) == 0)) {
assert index == mask + 1;
values[index] = value;
hasEmptyKey = true;
} else {
assert ((keys[index]) == 0);
if (assigned == resizeAt) {
allocateThenInsertThenRehash(index, key, value);
} else {
keys[index] = key;
values[index] = value;
}
assigned++;
}
}
@Override
public void clear() {
assigned = 0;
hasEmptyKey = false;
Arrays.fill(keys, ((short) 0));
}
@Override
public void release() {
assigned = 0;
hasEmptyKey = false;
keys = null;
values = null;
ensureCapacity(Containers.DEFAULT_EXPECTED_ELEMENTS);
}
@Override
public int size() {
return assigned + (hasEmptyKey ? 1 : 0);
}
public boolean isEmpty() {
return size() == 0;
}
@Override
public int hashCode() {
int h = hasEmptyKey ? 0xDEADBEEF : 0;
for (ShortFloatCursor c : this) {
h += BitMixer.mix(c.key) +
BitMixer.mix(c.value);
}
return h;
}
@Override
public boolean equals(Object obj) {
return obj != null &&
getClass() == obj.getClass() &&
equalElements(getClass().cast(obj));
}
protected boolean equalElements(ShortFloatHashMap other) {
if (other.size() != size()) {
return false;
}
for (ShortFloatCursor c : other) {
short key = c.key;
if (!containsKey(key) ||
!(Float.floatToIntBits(get(key)) == Float.floatToIntBits(c.value))) {
return false;
}
}
return true;
}
@Override
public void ensureCapacity(int expectedElements) {
if (expectedElements > resizeAt || keys == null) {
final short[] prevKeys = this.keys;
final float[] prevValues = this.values;
allocateBuffers(minBufferSize(expectedElements, loadFactor));
if (prevKeys != null && !isEmpty()) {
rehash(prevKeys, prevValues);
}
}
}
private final class EntryIterator extends AbstractIterator<ShortFloatCursor> {
private final ShortFloatCursor cursor;
private final int max = mask + 1;
private int slot = -1;
public EntryIterator() {
cursor = new ShortFloatCursor();
}
@Override
protected ShortFloatCursor fetch() {
if (slot < max) {
short existing;
for (slot++; slot < max; slot++) {
if (!((existing = keys[slot]) == 0)) {
cursor.index = slot;
cursor.key = existing;
cursor.value = values[slot];
return cursor;
}
}
}
if (slot == max && hasEmptyKey) {
cursor.index = slot;
cursor.key = ((short) 0);
cursor.value = values[max];
slot++;
return cursor;
}
return done();
}
}
@Override
public Iterator<ShortFloatCursor> iterator() {
return new EntryIterator();
}
@Override
public <T extends ShortFloatProcedure> T forEach(T procedure) {
final short[] keys = this.keys;
final float[] values = this.values;
if (hasEmptyKey) {
procedure.apply(((short) 0), values[mask + 1]);
}
for (int slot = 0, max = this.mask; slot <= max; slot++) {
if (!((keys[slot]) == 0)) {
procedure.apply(keys[slot], values[slot]);
}
}
return procedure;
}
@Override
public <T extends ShortFloatPredicate> T forEach(T predicate) {
final short[] keys = this.keys;
final float[] values = this.values;
if (hasEmptyKey) {
if (!predicate.apply(((short) 0), values[mask + 1])) {
return predicate;
}
}
for (int slot = 0, max = this.mask; slot <= max; slot++) {
if (!((keys[slot]) == 0)) {
if (!predicate.apply(keys[slot], values[slot])) {
break;
}
}
}
return predicate;
}
public KeysContainer keys() {
return new KeysContainer();
}
public final class KeysContainer extends AbstractShortCollection
implements ShortLookupContainer {
private final ShortFloatHashMap owner = ShortFloatHashMap.this;
@Override
public boolean contains(short e) {
return owner.containsKey(e);
}
@Override
public <T extends ShortProcedure> T forEach(final T procedure) {
owner.forEach(new ShortFloatProcedure() {
@Override
public void apply(short key, float value) {
procedure.apply(key);
}
});
return procedure;
}
@Override
public <T extends ShortPredicate> T forEach(final T predicate) {
owner.forEach(new ShortFloatPredicate() {
@Override
public boolean apply(short key, float value) {
return predicate.apply(key);
}
});
return predicate;
}
@Override
public boolean isEmpty() {
return owner.isEmpty();
}
@Override
public Iterator<ShortCursor> iterator() {
return new KeysIterator();
}
@Override
public int size() {
return owner.size();
}
@Override
public void clear() {
owner.clear();
}
@Override
public void release() {
owner.release();
}
@Override
public int removeAll(ShortPredicate predicate) {
return owner.removeAll(predicate);
}
@Override
public int removeAll(final short e) {
final boolean hasKey = owner.containsKey(e);
if (hasKey) {
owner.remove(e);
return 1;
} else {
return 0;
}
}
};
private final class KeysIterator extends AbstractIterator<ShortCursor> {
private final ShortCursor cursor;
private final int max = mask + 1;
private int slot = -1;
public KeysIterator() {
cursor = new ShortCursor();
}
@Override
protected ShortCursor fetch() {
if (slot < max) {
short existing;
for (slot++; slot < max; slot++) {
if (!((existing = keys[slot]) == 0)) {
cursor.index = slot;
cursor.value = existing;
return cursor;
}
}
}
if (slot == max && hasEmptyKey) {
cursor.index = slot;
cursor.value = ((short) 0);
slot++;
return cursor;
}
return done();
}
}
@Override
public FloatCollection values() {
return new ValuesContainer();
}
private final class ValuesContainer extends AbstractFloatCollection {
private final ShortFloatHashMap owner = ShortFloatHashMap.this;
@Override
public int size() {
return owner.size();
}
@Override
public boolean isEmpty() {
return owner.isEmpty();
}
@Override
public boolean contains(float value) {
for (ShortFloatCursor c : owner) {
if ((Float.floatToIntBits(c.value) == Float.floatToIntBits(value))) {
return true;
}
}
return false;
}
@Override
public <T extends FloatProcedure> T forEach(T procedure) {
for (ShortFloatCursor c : owner) {
procedure.apply(c.value);
}
return procedure;
}
@Override
public <T extends FloatPredicate> T forEach(T predicate) {
for (ShortFloatCursor c : owner) {
if (!predicate.apply(c.value)) {
break;
}
}
return predicate;
}
@Override
public Iterator<FloatCursor> iterator() {
return new ValuesIterator();
}
@Override
public int removeAll(final float e) {
return owner.removeAll(new ShortFloatPredicate() {
@Override
public boolean apply(short key, float value) {
return (Float.floatToIntBits(value) == Float.floatToIntBits(e));
}
});
}
@Override
public int removeAll(final FloatPredicate predicate) {
return owner.removeAll(new ShortFloatPredicate() {
@Override
public boolean apply(short key, float value) {
return predicate.apply(value);
}
});
}
@Override
public void clear() {
owner.clear();
}
@Override
public void release() {
owner.release();
}
}
private final class ValuesIterator extends AbstractIterator<FloatCursor> {
private final FloatCursor cursor;
private final int max = mask + 1;
private int slot = -1;
public ValuesIterator() {
cursor = new FloatCursor();
}
@Override
protected FloatCursor fetch() {
if (slot < max) {
for (slot++; slot < max; slot++) {
if (!(( keys[slot]) == 0)) {
cursor.index = slot;
cursor.value = values[slot];
return cursor;
}
}
}
if (slot == max && hasEmptyKey) {
cursor.index = slot;
cursor.value = values[max];
slot++;
return cursor;
}
return done();
}
}
@Override
public ShortFloatHashMap clone() {
try {
ShortFloatHashMap cloned = (ShortFloatHashMap) super.clone();
cloned.keys = keys.clone();
cloned.values = values.clone();
cloned.hasEmptyKey = cloned.hasEmptyKey;
cloned.orderMixer = orderMixer.clone();
return cloned;
} catch (CloneNotSupportedException e) {
throw new RuntimeException(e);
}
}
@Override
public String toString() {
final StringBuilder buffer = new StringBuilder();
buffer.append("[");
boolean first = true;
for (ShortFloatCursor cursor : this) {
if (!first) {
buffer.append(", ");
}
buffer.append(cursor.key);
buffer.append("=>");
buffer.append(cursor.value);
first = false;
}
buffer.append("]");
return buffer.toString();
}
@Override
public String visualizeKeyDistribution(int characters) {
return ShortBufferVisualizer.visualizeKeyDistribution(keys, mask, characters);
}
public static ShortFloatHashMap from(short[] keys, float[] values) {
if (keys.length != values.length) {
throw new IllegalArgumentException("Arrays of keys and values must have an identical length.");
}
ShortFloatHashMap map = new ShortFloatHashMap(keys.length);
for (int i = 0; i < keys.length; i++) {
map.put(keys[i], values[i]);
}
return map;
}
protected
int hashKey(short key) {
assert !((key) == 0);
return BitMixer.mix(key, this.keyMixer);
}
protected double verifyLoadFactor(double loadFactor) {
checkLoadFactor(loadFactor, MIN_LOAD_FACTOR, MAX_LOAD_FACTOR);
return loadFactor;
}
protected void rehash(short[] fromKeys, float[] fromValues) {
assert fromKeys.length == fromValues.length &&
HashContainers.checkPowerOfTwo(fromKeys.length - 1);
final short[] keys = this.keys;
final float[] values = this.values;
final int mask = this.mask;
short existing;
int from = fromKeys.length - 1;
keys[keys.length - 1] = fromKeys[from];
values[values.length - 1] = fromValues[from];
while (--from >= 0) {
if (!((existing = fromKeys[from]) == 0)) {
int slot = hashKey(existing) & mask;
while (!((keys[slot]) == 0)) {
slot = (slot + 1) & mask;
}
keys[slot] = existing;
values[slot] = fromValues[from];
}
}
}
protected void allocateBuffers(int arraySize) {
assert Integer.bitCount(arraySize) == 1;
final int newKeyMixer = this.orderMixer.newKeyMixer(arraySize);
short[] prevKeys = this.keys;
float[] prevValues = this.values;
try {
int emptyElementSlot = 1;
this.keys = (new short [arraySize + emptyElementSlot]);
this.values = (new float [arraySize + emptyElementSlot]);
} catch (OutOfMemoryError e) {
this.keys = prevKeys;
this.values = prevValues;
throw new BufferAllocationException(
"Not enough memory to allocate buffers for rehashing: %,d -> %,d",
e,
this.mask + 1,
arraySize);
}
this.resizeAt = expandAtCount(arraySize, loadFactor);
this.keyMixer = newKeyMixer;
this.mask = arraySize - 1;
}
protected void allocateThenInsertThenRehash(int slot, short pendingKey, float pendingValue) {
assert assigned == resizeAt
&& (( keys[slot]) == 0)
&& !((pendingKey) == 0);
final short[] prevKeys = this.keys;
final float[] prevValues = this.values;
allocateBuffers(nextBufferSize(mask + 1, size(), loadFactor));
assert this.keys.length > prevKeys.length;
prevKeys[slot] = pendingKey;
prevValues[slot] = pendingValue;
rehash(prevKeys, prevValues);
}
protected void shiftConflictingKeys(int gapSlot) {
final short[] keys = this.keys;
final float[] values = this.values;
final int mask = this.mask;
int distance = 0;
while (true) {
final int slot = (gapSlot + (++distance)) & mask;
final short existing = keys[slot];
if (((existing) == 0)) {
break;
}
final int idealSlot = hashKey(existing);
final int shift = (slot - idealSlot) & mask;
if (shift >= distance) {
keys[gapSlot] = existing;
values[gapSlot] = values[slot];
gapSlot = slot;
distance = 0;
}
}
keys[gapSlot] = ((short) 0);
values[gapSlot] = 0f;
assigned--;
}
}