/* */ public short putAndMoveToFirst(long k, short v)
/* */ {
/* 512 */ long[] key = this.key;
/* 513 */ boolean[] used = this.used;
/* 514 */ int mask = this.mask;
/* */
/* 516 */ int pos = (int)HashCommon.murmurHash3(k) & mask;
/* */
/* 518 */ while (used[pos] != 0) {
/* 519 */ if (k == key[pos]) {
/* 520 */ short oldValue = this.value[pos];
/* 521 */ this.value[pos] = v;
/* 522 */ moveIndexToFirst(pos);
/* 523 */ return oldValue;
/* */ }
/* 525 */ pos = pos + 1 & mask;
/* */ }
/* 527 */ used[pos] = true;
/* 528 */ key[pos] = k;
/* 529 */ this.value[pos] = v;
/* 530 */ if (this.size == 0) {
/* 531 */ this.first = (this.last = pos);
/* */
/* 533 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 536 */ this.link[this.first] ^= (this.link[this.first] ^ (pos & 0xFFFFFFFF) << 32) & 0x0;
/* 537 */ this.link[pos] = (0x0 | this.first & 0xFFFFFFFF);
/* 538 */ this.first = pos;
/* */ }
/* 540 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size, this.f));
/* */
/* 542 */ return this.defRetValue;
/* */ }
/* */ public short add(long k, short incr)
/* */ {
/* 305 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask;
/* */
/* 307 */ while (this.used[pos] != 0) {
/* 308 */ if (this.key[pos] == k) {
/* 309 */ short oldValue = this.value[pos];
/* */ int tmp49_47 = pos;
/* */ short[] tmp49_44 = this.value; tmp49_44[tmp49_47] = ((short)(tmp49_44[tmp49_47] + incr));
/* 311 */ return tmp49_47;
/* */ }
/* 313 */ pos = pos + 1 & this.mask;
/* */ }
/* 315 */ this.used[pos] = true;
/* 316 */ this.key[pos] = k;
/* 317 */ this.value[pos] = ((short)(this.defRetValue + incr));
/* 318 */ if (this.size == 0) {
/* 319 */ this.first = (this.last = pos);
/* */
/* 321 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 324 */ this.link[this.last] ^= (this.link[this.last] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 325 */ this.link[pos] = ((this.last & 0xFFFFFFFF) << 32 | 0xFFFFFFFF);
/* 326 */ this.last = pos;
/* */ }
/* 328 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f));
/* */
/* 330 */ return this.defRetValue;
/* */ }
/* */ public Short put(Long ok, Short ov) {
/* 262 */ short v = ov.shortValue();
/* 263 */ long k = ok.longValue();
/* */
/* 265 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask;
/* */
/* 267 */ while (this.used[pos] != 0) {
/* 268 */ if (this.key[pos] == k) {
/* 269 */ Short oldValue = Short.valueOf(this.value[pos]);
/* 270 */ this.value[pos] = v;
/* 271 */ return oldValue;
/* */ }
/* 273 */ pos = pos + 1 & this.mask;
/* */ }
/* 275 */ this.used[pos] = true;
/* 276 */ this.key[pos] = k;
/* 277 */ this.value[pos] = v;
/* 278 */ if (this.size == 0) {
/* 279 */ this.first = (this.last = pos);
/* */
/* 281 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 284 */ this.link[this.last] ^= (this.link[this.last] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 285 */ this.link[pos] = ((this.last & 0xFFFFFFFF) << 32 | 0xFFFFFFFF);
/* 286 */ this.last = pos;
/* */ }
/* 288 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f));
/* */
/* 290 */ return null;
/* */ }
/* */ protected void rehash(int newN)
/* */ {
/* 716 */ int i = 0;
/* 717 */ boolean[] used = this.used;
/* */
/* 719 */ Object[] key = this.key;
/* 720 */ int[] value = this.value;
/* 721 */ int newMask = newN - 1;
/* 722 */ Object[] newKey = (Object[])new Object[newN];
/* 723 */ int[] newValue = new int[newN];
/* 724 */ boolean[] newUsed = new boolean[newN];
/* 725 */ for (int j = this.size; j-- != 0; ) {
/* 726 */ while (used[i] == 0) i++;
/* 727 */ Object k = key[i];
/* 728 */ int pos = (k == null ? 142593372 : HashCommon.murmurHash3(System.identityHashCode(k))) & newMask;
/* 729 */ while (newUsed[pos] != 0) pos = pos + 1 & newMask;
/* 730 */ newUsed[pos] = true;
/* 731 */ newKey[pos] = k;
/* 732 */ newValue[pos] = value[i];
/* 733 */ i++;
/* */ }
/* 735 */ this.n = newN;
/* 736 */ this.mask = newMask;
/* 737 */ this.maxFill = HashCommon.maxFill(this.n, this.f);
/* 738 */ this.key = newKey;
/* 739 */ this.value = newValue;
/* 740 */ this.used = newUsed;
/* */ }
/* */ public short putAndMoveToLast(long k, short v)
/* */ {
/* 551 */ long[] key = this.key;
/* 552 */ boolean[] used = this.used;
/* 553 */ int mask = this.mask;
/* */
/* 555 */ int pos = (int)HashCommon.murmurHash3(k) & mask;
/* */
/* 557 */ while (used[pos] != 0) {
/* 558 */ if (k == key[pos]) {
/* 559 */ short oldValue = this.value[pos];
/* 560 */ this.value[pos] = v;
/* 561 */ moveIndexToLast(pos);
/* 562 */ return oldValue;
/* */ }
/* 564 */ pos = pos + 1 & mask;
/* */ }
/* 566 */ used[pos] = true;
/* 567 */ key[pos] = k;
/* 568 */ this.value[pos] = v;
/* 569 */ if (this.size == 0) {
/* 570 */ this.first = (this.last = pos);
/* */
/* 572 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 575 */ this.link[this.last] ^= (this.link[this.last] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 576 */ this.link[pos] = ((this.last & 0xFFFFFFFF) << 32 | 0xFFFFFFFF);
/* 577 */ this.last = pos;
/* */ }
/* 579 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size, this.f));
/* */
/* 581 */ return this.defRetValue;
/* */ }
/* */ public char putAndMoveToFirst(float k, char v)
/* */ {
/* 472 */ float[] key = this.key;
/* 473 */ boolean[] used = this.used;
/* 474 */ int mask = this.mask;
/* */
/* 476 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & mask;
/* */
/* 478 */ while (used[pos] != 0) {
/* 479 */ if (k == key[pos]) {
/* 480 */ char oldValue = this.value[pos];
/* 481 */ this.value[pos] = v;
/* 482 */ moveIndexToFirst(pos);
/* 483 */ return oldValue;
/* */ }
/* 485 */ pos = pos + 1 & mask;
/* */ }
/* 487 */ used[pos] = true;
/* 488 */ key[pos] = k;
/* 489 */ this.value[pos] = v;
/* 490 */ if (this.size == 0) {
/* 491 */ this.first = (this.last = pos);
/* */
/* 493 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 496 */ this.link[this.first] ^= (this.link[this.first] ^ (pos & 0xFFFFFFFF) << 32) & 0x0;
/* 497 */ this.link[pos] = (0x0 | this.first & 0xFFFFFFFF);
/* 498 */ this.first = pos;
/* */ }
/* 500 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size, this.f));
/* */
/* 502 */ return this.defRetValue;
/* */ }
/* */ protected void rehash(int newN)
/* */ {
/* 736 */ int i = 0;
/* 737 */ boolean[] used = this.used;
/* */
/* 739 */ Object[] key = this.key;
/* 740 */ double[] value = this.value;
/* 741 */ int newMask = newN - 1;
/* 742 */ Object[] newKey = (Object[])new Object[newN];
/* 743 */ double[] newValue = new double[newN];
/* 744 */ boolean[] newUsed = new boolean[newN];
/* 745 */ for (int j = this.size; j-- != 0; ) {
/* 746 */ while (used[i] == 0) i++;
/* 747 */ Object k = key[i];
/* 748 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & newMask;
/* 749 */ while (newUsed[pos] != 0) pos = pos + 1 & newMask;
/* 750 */ newUsed[pos] = true;
/* 751 */ newKey[pos] = k;
/* 752 */ newValue[pos] = value[i];
/* 753 */ i++;
/* */ }
/* 755 */ this.n = newN;
/* 756 */ this.mask = newMask;
/* 757 */ this.maxFill = HashCommon.maxFill(this.n, this.f);
/* 758 */ this.key = newKey;
/* 759 */ this.value = newValue;
/* 760 */ this.used = newUsed;
/* */ }
public Float put(final Long ok, final Float ov) {
final float v = ((ov).floatValue());
final long k = ((ok).longValue());
// The starting point.
int pos = (int) it.unimi.dsi.fastutil.HashCommon.murmurHash3(k) & mask;
// There's always an unused entry.
while (used[pos]) {
if (((key[pos]) == (k))) {
final Float oldValue = (Float.valueOf(value[pos]));
value[pos] = v;
return oldValue;
}
pos = (pos + 1) & mask;
}
used[pos] = true;
key[pos] = k;
value[pos] = v;
if (size == 0) {
first = last = pos;
// Special case of SET_UPPER_LOWER( link[ pos ], -1, -1 );
link[pos] = -1L;
} else {
link[last] ^= ((link[last] ^ (pos & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
link[pos] = ((last & 0xFFFFFFFFL) << 32) | (-1 & 0xFFFFFFFFL);
last = pos;
}
if (++size >= maxFill) rehash(arraySize(size + 1, f));
if (ASSERTS) checkTable();
return (null);
}
/* */ public char putAndMoveToLast(float k, char v)
/* */ {
/* 511 */ float[] key = this.key;
/* 512 */ boolean[] used = this.used;
/* 513 */ int mask = this.mask;
/* */
/* 515 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & mask;
/* */
/* 517 */ while (used[pos] != 0) {
/* 518 */ if (k == key[pos]) {
/* 519 */ char oldValue = this.value[pos];
/* 520 */ this.value[pos] = v;
/* 521 */ moveIndexToLast(pos);
/* 522 */ return oldValue;
/* */ }
/* 524 */ pos = pos + 1 & mask;
/* */ }
/* 526 */ used[pos] = true;
/* 527 */ key[pos] = k;
/* 528 */ this.value[pos] = v;
/* 529 */ if (this.size == 0) {
/* 530 */ this.first = (this.last = pos);
/* */
/* 532 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 535 */ this.link[this.last] ^= (this.link[this.last] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 536 */ this.link[pos] = ((this.last & 0xFFFFFFFF) << 32 | 0xFFFFFFFF);
/* 537 */ this.last = pos;
/* */ }
/* 539 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size, this.f));
/* */
/* 541 */ return this.defRetValue;
/* */ }
/* */ public Character put(Float ok, Character ov) {
/* 262 */ char v = ov.charValue();
/* 263 */ float k = ok.floatValue();
/* */
/* 265 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask;
/* */
/* 267 */ while (this.used[pos] != 0) {
/* 268 */ if (this.key[pos] == k) {
/* 269 */ Character oldValue = Character.valueOf(this.value[pos]);
/* 270 */ this.value[pos] = v;
/* 271 */ return oldValue;
/* */ }
/* 273 */ pos = pos + 1 & this.mask;
/* */ }
/* 275 */ this.used[pos] = true;
/* 276 */ this.key[pos] = k;
/* 277 */ this.value[pos] = v;
/* 278 */ if (this.size == 0) {
/* 279 */ this.first = (this.last = pos);
/* */
/* 281 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 284 */ this.link[this.last] ^= (this.link[this.last] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 285 */ this.link[pos] = ((this.last & 0xFFFFFFFF) << 32 | 0xFFFFFFFF);
/* 286 */ this.last = pos;
/* */ }
/* 288 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f));
/* */
/* 290 */ return null;
/* */ }
/**
* Resizes the map.
*
* <p>This method implements the basic rehashing strategy, and may be overriden by subclasses
* implementing different rehashing strategies (e.g., disk-based rehashing). However, you should
* not override this method unless you understand the internal workings of this class.
*
* @param newN the new size
*/
@SuppressWarnings("unchecked")
protected void rehash(final int newN) {
int i = 0, pos;
final boolean used[] = this.used;
double k;
final double key[] = this.key;
final double value[] = this.value;
final int newMask = newN - 1;
final double newKey[] = new double[newN];
final double newValue[] = new double[newN];
final boolean newUsed[] = new boolean[newN];
for (int j = size; j-- != 0; ) {
while (!used[i]) i++;
k = key[i];
pos = (it.unimi.dsi.fastutil.HashCommon.murmurHash3(strategy.hashCode(k))) & newMask;
while (newUsed[pos]) pos = (pos + 1) & newMask;
newUsed[pos] = true;
newKey[pos] = k;
newValue[pos] = value[i];
i++;
}
n = newN;
mask = newMask;
maxFill = maxFill(n, f);
this.key = newKey;
this.value = newValue;
this.used = newUsed;
}
/**
* Shifts left entries with the specified hash code, starting at the specified position, and
* empties the resulting free entry. If any entry wraps around the table, instantiates lazily
* {@link #wrapped} and stores the entry key.
*
* @param pos a starting position.
* @return the position cleared by the shifting process.
*/
protected final int shiftKeys(int pos) {
// Shift entries with the same hash.
int last, slot;
for (; ; ) {
pos = ((last = pos) + 1) & mask;
while (used[pos]) {
slot =
(it.unimi.dsi.fastutil.HashCommon.murmurHash3(strategy.hashCode((K) (key[pos]))))
& mask;
if (last <= pos ? last >= slot || slot > pos : last >= slot && slot > pos) break;
pos = (pos + 1) & mask;
}
if (!used[pos]) break;
if (pos < last) {
// Wrapped entry.
if (wrapped == null) wrapped = new ObjectArrayList<K>();
wrapped.add(key[pos]);
}
key[last] = key[pos];
value[last] = value[pos];
}
used[last] = false;
key[last] = null;
return last;
}
/* */ public char put(float k, char v)
/* */ {
/* 234 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask;
/* */
/* 236 */ while (this.used[pos] != 0) {
/* 237 */ if (this.key[pos] == k) {
/* 238 */ char oldValue = this.value[pos];
/* 239 */ this.value[pos] = v;
/* 240 */ return oldValue;
/* */ }
/* 242 */ pos = pos + 1 & this.mask;
/* */ }
/* 244 */ this.used[pos] = true;
/* 245 */ this.key[pos] = k;
/* 246 */ this.value[pos] = v;
/* 247 */ if (this.size == 0) {
/* 248 */ this.first = (this.last = pos);
/* */
/* 250 */ this.link[pos] = -1L;
/* */ }
/* */ else {
/* 253 */ this.link[this.last] ^= (this.link[this.last] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 254 */ this.link[pos] = ((this.last & 0xFFFFFFFF) << 32 | 0xFFFFFFFF);
/* 255 */ this.last = pos;
/* */ }
/* 257 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f));
/* */
/* 259 */ return this.defRetValue;
/* */ }
public int nextEntry() {
if (!hasNext()) throw new NoSuchElementException();
c--;
// We are just enumerating elements from the wrapped list.
if (pos < 0) {
final Object k = wrapped.get(-(last = --pos) - 2);
// The starting point.
int pos =
(it.unimi.dsi.fastutil.HashCommon.murmurHash3(strategy.hashCode((K) ((K) k)))) & mask;
// There's always an unused entry.
while (used[pos]) {
if ((strategy.equals((key[pos]), (K) ((K) k)))) return pos;
pos = (pos + 1) & mask;
}
}
last = pos;
// System.err.println( "Count: " + c );
if (c != 0) {
final boolean used[] = Object2CharOpenCustomHashMap.this.used;
while (pos-- != 0 && !used[pos]) ;
// When here pos < 0 there are no more elements to be enumerated by scanning, but wrapped
// might be nonempty.
}
return last;
}
/**
* Adds a pair to the map; if the key is already present, it is moved to the last position of the
* iteration order.
*
* @param k the key.
* @param v the value.
* @return the old value, or the {@linkplain #defaultReturnValue() default return value} if no
* value was present for the given key.
*/
public float putAndMoveToLast(final long k, final float v) {
final long key[] = this.key;
final boolean used[] = this.used;
final int mask = this.mask;
// The starting point.
int pos = (int) it.unimi.dsi.fastutil.HashCommon.murmurHash3(k) & mask;
// There's always an unused entry.
while (used[pos]) {
if (((k) == (key[pos]))) {
final float oldValue = value[pos];
value[pos] = v;
moveIndexToLast(pos);
return oldValue;
}
pos = (pos + 1) & mask;
}
used[pos] = true;
key[pos] = k;
value[pos] = v;
if (size == 0) {
first = last = pos;
// Special case of SET_UPPER_LOWER( link[ pos ], -1, -1 );
link[pos] = -1L;
} else {
link[last] ^= ((link[last] ^ (pos & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
link[pos] = ((last & 0xFFFFFFFFL) << 32) | (-1 & 0xFFFFFFFFL);
last = pos;
}
if (++size >= maxFill) rehash(arraySize(size, f));
if (ASSERTS) checkTable();
return defRetValue;
}
/**
* Adds an increment to value currently associated with a key.
*
* <p>Note that this method respects the {@linkplain #defaultReturnValue() default return value}
* semantics: when called with a key that does not currently appears in the map, the key will be
* associated with the default return value plus the given increment.
*
* @param k the key.
* @param incr the increment.
* @return the old value, or the {@linkplain #defaultReturnValue() default return value} if no
* value was present for the given key.
*/
public float addTo(final long k, final float incr) {
// The starting point.
int pos = (int) it.unimi.dsi.fastutil.HashCommon.murmurHash3(k) & mask;
// There's always an unused entry.
while (used[pos]) {
if (((key[pos]) == (k))) {
final float oldValue = value[pos];
value[pos] += incr;
return oldValue;
}
pos = (pos + 1) & mask;
}
used[pos] = true;
key[pos] = k;
value[pos] = defRetValue + incr;
if (size == 0) {
first = last = pos;
// Special case of SET_UPPER_LOWER( link[ pos ], -1, -1 );
link[pos] = -1L;
} else {
link[last] ^= ((link[last] ^ (pos & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
link[pos] = ((last & 0xFFFFFFFFL) << 32) | (-1 & 0xFFFFFFFFL);
last = pos;
}
if (++size >= maxFill) rehash(arraySize(size + 1, f));
if (ASSERTS) checkTable();
return defRetValue;
}
/* */ protected void rehash(int newN)
/* */ {
/* 729 */ int i = 0;
/* 730 */ boolean[] used = this.used;
/* */
/* 732 */ long[] key = this.key;
/* 733 */ byte[] value = this.value;
/* 734 */ int newMask = newN - 1;
/* 735 */ long[] newKey = new long[newN];
/* 736 */ byte[] newValue = new byte[newN];
/* 737 */ boolean[] newUsed = new boolean[newN];
/* 738 */ for (int j = this.size; j-- != 0; ) {
/* 739 */ while (used[i] == 0) i++;
/* 740 */ long k = key[i];
/* 741 */ int pos = (int)HashCommon.murmurHash3(k) & newMask;
/* 742 */ while (newUsed[pos] != 0) pos = pos + 1 & newMask;
/* 743 */ newUsed[pos] = true;
/* 744 */ newKey[pos] = k;
/* 745 */ newValue[pos] = value[i];
/* 746 */ i++;
/* */ }
/* 748 */ this.n = newN;
/* 749 */ this.mask = newMask;
/* 750 */ this.maxFill = HashCommon.maxFill(this.n, this.f);
/* 751 */ this.key = newKey;
/* 752 */ this.value = newValue;
/* 753 */ this.used = newUsed;
/* */ }
/* */ public byte get(long k)
/* */ {
/* 327 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask;
/* */
/* 329 */ while (this.used[pos] != 0) {
/* 330 */ if (this.key[pos] == k) return this.value[pos];
/* 331 */ pos = pos + 1 & this.mask;
/* */ }
/* 333 */ return this.defRetValue;
/* */ }
/* */ public boolean containsKey(long k)
/* */ {
/* 328 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask;
/* */
/* 330 */ while (this.used[pos] != 0) {
/* 331 */ if (this.strategy.equals(this.key[pos], k)) return true;
/* 332 */ pos = pos + 1 & this.mask;
/* */ }
/* 334 */ return false;
/* */ }
/* */ public boolean get(long k)
/* */ {
/* 317 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask;
/* */
/* 319 */ while (this.used[pos] != 0) {
/* 320 */ if (this.strategy.equals(this.key[pos], k)) return this.value[pos];
/* 321 */ pos = pos + 1 & this.mask;
/* */ }
/* 323 */ return this.defRetValue;
/* */ }
/* */ public char get(float k)
/* */ {
/* 557 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask;
/* */
/* 559 */ while (this.used[pos] != 0) {
/* 560 */ if (this.key[pos] == k) return this.value[pos];
/* 561 */ pos = pos + 1 & this.mask;
/* */ }
/* 563 */ return this.defRetValue;
/* */ }
/* */ public boolean containsKey(long k)
/* */ {
/* 338 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask;
/* */
/* 340 */ while (this.used[pos] != 0) {
/* 341 */ if (this.key[pos] == k) return true;
/* 342 */ pos = pos + 1 & this.mask;
/* */ }
/* 344 */ return false;
/* */ }
/* */ public boolean containsKey(Object k)
/* */ {
/* 327 */ int pos = (k == null ? 142593372 : HashCommon.murmurHash3(System.identityHashCode(k))) & this.mask;
/* */
/* 329 */ while (this.used[pos] != 0) {
/* 330 */ if (this.key[pos] == k) return true;
/* 331 */ pos = pos + 1 & this.mask;
/* */ }
/* 333 */ return false;
/* */ }
/* */ public boolean containsKey(float k)
/* */ {
/* 568 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask;
/* */
/* 570 */ while (this.used[pos] != 0) {
/* 571 */ if (this.key[pos] == k) return true;
/* 572 */ pos = pos + 1 & this.mask;
/* */ }
/* 574 */ return false;
/* */ }
/* */ public int getInt(Object k)
/* */ {
/* 316 */ int pos = (k == null ? 142593372 : HashCommon.murmurHash3(System.identityHashCode(k))) & this.mask;
/* */
/* 318 */ while (this.used[pos] != 0) {
/* 319 */ if (this.key[pos] == k) return this.value[pos];
/* 320 */ pos = pos + 1 & this.mask;
/* */ }
/* 322 */ return this.defRetValue;
/* */ }
/* */ public short get(long k)
/* */ {
/* 597 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask;
/* */
/* 599 */ while (this.used[pos] != 0) {
/* 600 */ if (this.key[pos] == k) return this.value[pos];
/* 601 */ pos = pos + 1 & this.mask;
/* */ }
/* 603 */ return this.defRetValue;
/* */ }
/* */ public boolean containsKey(Object k)
/* */ {
/* 347 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask;
/* */
/* 349 */ while (this.used[pos] != 0) {
/* 350 */ if (this.strategy.equals(this.key[pos], k)) return true;
/* 351 */ pos = pos + 1 & this.mask;
/* */ }
/* 353 */ return false;
/* */ }
/* */ public double getDouble(Object k)
/* */ {
/* 336 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask;
/* */
/* 338 */ while (this.used[pos] != 0) {
/* 339 */ if (this.strategy.equals(this.key[pos], k)) return this.value[pos];
/* 340 */ pos = pos + 1 & this.mask;
/* */ }
/* 342 */ return this.defRetValue;
/* */ }
public Double get(final Double ok) {
final double k = ((ok).doubleValue());
// The starting point.
int pos = (it.unimi.dsi.fastutil.HashCommon.murmurHash3(strategy.hashCode(k))) & mask;
// There's always an unused entry.
while (used[pos]) {
if ((strategy.equals((key[pos]), (k)))) return (Double.valueOf(value[pos]));
pos = (pos + 1) & mask;
}
return (null);
}
@SuppressWarnings("unchecked")
public boolean containsKey(final double k) {
// The starting point.
int pos = (it.unimi.dsi.fastutil.HashCommon.murmurHash3(strategy.hashCode(k))) & mask;
// There's always an unused entry.
while (used[pos]) {
if ((strategy.equals((key[pos]), (k)))) return true;
pos = (pos + 1) & mask;
}
return false;
}