/* */ 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; }