/* */ 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; /* */ }
/* */ 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; /* */ }
/* */ 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 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 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 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; /* */ }
/* */ 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 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 boolean trim() /* */ { /* 690 */ int l = HashCommon.arraySize(this.size, this.f); /* 691 */ if (l >= this.n) return true; try /* */ { /* 693 */ rehash(l); /* */ } catch (OutOfMemoryError cantDoIt) { /* 695 */ return false; /* 696 */ }return true; /* */ }
/* */ public Long2ByteOpenHashMap(int expected, float f) /* */ { /* 107 */ if ((f <= 0.0F) || (f > 1.0F)) throw new IllegalArgumentException("Load factor must be greater than 0 and smaller than or equal to 1"); /* 108 */ if (expected < 0) throw new IllegalArgumentException("The expected number of elements must be nonnegative"); /* 109 */ this.f = f; /* 110 */ this.n = HashCommon.arraySize(expected, f); /* 111 */ this.mask = (this.n - 1); /* 112 */ this.maxFill = HashCommon.maxFill(this.n, f); /* 113 */ this.key = new long[this.n]; /* 114 */ this.value = new byte[this.n]; /* 115 */ this.used = new boolean[this.n]; /* */ }
/* */ public Float2CharLinkedOpenHashMap(int expected, float f) /* */ { /* 151 */ if ((f <= 0.0F) || (f > 1.0F)) throw new IllegalArgumentException("Load factor must be greater than 0 and smaller than or equal to 1"); /* 152 */ if (expected < 0) throw new IllegalArgumentException("The expected number of elements must be nonnegative"); /* 153 */ this.f = f; /* 154 */ this.n = HashCommon.arraySize(expected, f); /* 155 */ this.mask = (this.n - 1); /* 156 */ this.maxFill = HashCommon.maxFill(this.n, f); /* 157 */ this.key = new float[this.n]; /* 158 */ this.value = new char[this.n]; /* 159 */ this.used = new boolean[this.n]; /* 160 */ this.link = new long[this.n]; /* */ }
/* */ public Object2DoubleOpenCustomHashMap(int expected, float f, Hash.Strategy<K> strategy) /* */ { /* 110 */ this.strategy = strategy; /* 111 */ if ((f <= 0.0F) || (f > 1.0F)) throw new IllegalArgumentException("Load factor must be greater than 0 and smaller than or equal to 1"); /* 112 */ if (expected < 0) throw new IllegalArgumentException("The expected number of elements must be nonnegative"); /* 113 */ this.f = f; /* 114 */ this.n = HashCommon.arraySize(expected, f); /* 115 */ this.mask = (this.n - 1); /* 116 */ this.maxFill = HashCommon.maxFill(this.n, f); /* 117 */ this.key = ((Object[])new Object[this.n]); /* 118 */ this.value = new double[this.n]; /* 119 */ this.used = new boolean[this.n]; /* */ }
/* */ public int add(K k, int incr) /* */ { /* 239 */ int pos = (k == null ? 142593372 : HashCommon.murmurHash3(System.identityHashCode(k))) & this.mask; /* */ /* 241 */ while (this.used[pos] != 0) { /* 242 */ if (this.key[pos] == k) { /* 243 */ int oldValue = this.value[pos]; /* 244 */ this.value[pos] += incr; /* 245 */ return oldValue; /* */ } /* 247 */ pos = pos + 1 & this.mask; /* */ } /* 249 */ this.used[pos] = true; /* 250 */ this.key[pos] = k; /* 251 */ this.value[pos] = (this.defRetValue + incr); /* 252 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 254 */ return this.defRetValue; /* */ }
public InMemoryJoinHash( LongArrayList addresses, PagesHashStrategy pagesHashStrategy, OperatorContext operatorContext) { this.addresses = checkNotNull(addresses, "addresses is null"); this.pagesHashStrategy = checkNotNull(pagesHashStrategy, "pagesHashStrategy is null"); this.channelCount = pagesHashStrategy.getChannelCount(); checkNotNull(operatorContext, "operatorContext is null"); // reserve memory for the arrays int hashSize = HashCommon.arraySize(addresses.size(), 0.75f); operatorContext.reserveMemory(sizeOfIntArray(hashSize) + sizeOfIntArray(addresses.size())); mask = hashSize - 1; key = new int[hashSize]; Arrays.fill(key, -1); this.positionLinks = new int[addresses.size()]; Arrays.fill(positionLinks, -1); // index pages for (int position = 0; position < addresses.size(); position++) { int pos = ((int) Murmur3.hash64(hashPosition(position))) & mask; // look for an empty slot or a slot containing this key while (key[pos] != -1) { int currentKey = key[pos]; if (positionEqualsPosition(currentKey, position)) { // found a slot for this key // link the new key position to the current key position positionLinks[position] = currentKey; // key[pos] updated outside of this loop break; } // increment position and mask to handler wrap around pos = (pos + 1) & mask; } key[pos] = position; } }
/* */ public int put(K k, int v) /* */ { /* 188 */ int pos = (k == null ? 142593372 : HashCommon.murmurHash3(System.identityHashCode(k))) & this.mask; /* */ /* 190 */ while (this.used[pos] != 0) { /* 191 */ if (this.key[pos] == k) { /* 192 */ int oldValue = this.value[pos]; /* 193 */ this.value[pos] = v; /* 194 */ return oldValue; /* */ } /* 196 */ pos = pos + 1 & this.mask; /* */ } /* 198 */ this.used[pos] = true; /* 199 */ this.key[pos] = k; /* 200 */ this.value[pos] = v; /* 201 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 203 */ return this.defRetValue; /* */ }
/* */ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { /* 800 */ s.defaultReadObject(); /* 801 */ this.n = HashCommon.arraySize(this.size, this.f); /* 802 */ this.maxFill = HashCommon.maxFill(this.n, this.f); /* 803 */ this.mask = (this.n - 1); /* 804 */ Object[] key = this.key = (Object[])new Object[this.n]; /* 805 */ int[] value = this.value = new int[this.n]; /* 806 */ boolean[] used = this.used = new boolean[this.n]; /* */ /* 809 */ int i = this.size; for (int pos = 0; i-- != 0; ) { /* 810 */ Object k = s.readObject(); /* 811 */ int v = s.readInt(); /* 812 */ pos = (k == null ? 142593372 : HashCommon.murmurHash3(System.identityHashCode(k))) & this.mask; /* 813 */ while (used[pos] != 0) pos = pos + 1 & this.mask; /* 814 */ used[pos] = true; /* 815 */ key[pos] = k; /* 816 */ value[pos] = v; /* */ } /* */ }
/* */ public boolean put(long k, boolean v) /* */ { /* 209 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask; /* */ /* 211 */ while (this.used[pos] != 0) { /* 212 */ if (this.strategy.equals(this.key[pos], k)) { /* 213 */ boolean oldValue = this.value[pos]; /* 214 */ this.value[pos] = v; /* 215 */ return oldValue; /* */ } /* 217 */ pos = pos + 1 & this.mask; /* */ } /* 219 */ this.used[pos] = true; /* 220 */ this.key[pos] = k; /* 221 */ this.value[pos] = v; /* 222 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 224 */ return this.defRetValue; /* */ }
/* */ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { /* 821 */ s.defaultReadObject(); /* 822 */ this.n = HashCommon.arraySize(this.size, this.f); /* 823 */ this.maxFill = HashCommon.maxFill(this.n, this.f); /* 824 */ this.mask = (this.n - 1); /* 825 */ Object[] key = this.key = (Object[])new Object[this.n]; /* 826 */ double[] value = this.value = new double[this.n]; /* 827 */ boolean[] used = this.used = new boolean[this.n]; /* */ /* 830 */ int i = this.size; for (int pos = 0; i-- != 0; ) { /* 831 */ Object k = s.readObject(); /* 832 */ double v = s.readDouble(); /* 833 */ pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask; /* 834 */ while (used[pos] != 0) pos = pos + 1 & this.mask; /* 835 */ used[pos] = true; /* 836 */ key[pos] = k; /* 837 */ value[pos] = v; /* */ } /* */ }
/* */ public double add(K k, double incr) /* */ { /* 259 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask; /* */ /* 261 */ while (this.used[pos] != 0) { /* 262 */ if (this.strategy.equals(this.key[pos], k)) { /* 263 */ double oldValue = this.value[pos]; /* 264 */ this.value[pos] += incr; /* 265 */ return oldValue; /* */ } /* 267 */ pos = pos + 1 & this.mask; /* */ } /* 269 */ this.used[pos] = true; /* 270 */ this.key[pos] = k; /* 271 */ this.value[pos] = (this.defRetValue + incr); /* 272 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 274 */ return this.defRetValue; /* */ }
/* */ public byte put(long k, byte v) /* */ { /* 189 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask; /* */ /* 191 */ while (this.used[pos] != 0) { /* 192 */ if (this.key[pos] == k) { /* 193 */ byte oldValue = this.value[pos]; /* 194 */ this.value[pos] = v; /* 195 */ return oldValue; /* */ } /* 197 */ pos = pos + 1 & this.mask; /* */ } /* 199 */ this.used[pos] = true; /* 200 */ this.key[pos] = k; /* 201 */ this.value[pos] = v; /* 202 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 204 */ return this.defRetValue; /* */ }
/* */ public double put(K k, double v) /* */ { /* 208 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask; /* */ /* 210 */ while (this.used[pos] != 0) { /* 211 */ if (this.strategy.equals(this.key[pos], k)) { /* 212 */ double oldValue = this.value[pos]; /* 213 */ this.value[pos] = v; /* 214 */ return oldValue; /* */ } /* 216 */ pos = pos + 1 & this.mask; /* */ } /* 218 */ this.used[pos] = true; /* 219 */ this.key[pos] = k; /* 220 */ this.value[pos] = v; /* 221 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 223 */ return this.defRetValue; /* */ }
/* */ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { /* 812 */ s.defaultReadObject(); /* 813 */ this.n = HashCommon.arraySize(this.size, this.f); /* 814 */ this.maxFill = HashCommon.maxFill(this.n, this.f); /* 815 */ this.mask = (this.n - 1); /* 816 */ long[] key = this.key = new long[this.n]; /* 817 */ byte[] value = this.value = new byte[this.n]; /* 818 */ boolean[] used = this.used = new boolean[this.n]; /* */ /* 821 */ int i = this.size; for (int pos = 0; i-- != 0; ) { /* 822 */ long k = s.readLong(); /* 823 */ byte v = s.readByte(); /* 824 */ pos = (int)HashCommon.murmurHash3(k) & this.mask; /* 825 */ while (used[pos] != 0) pos = pos + 1 & this.mask; /* 826 */ used[pos] = true; /* 827 */ key[pos] = k; /* 828 */ value[pos] = v; /* */ } /* */ }
/* */ public byte add(long k, byte incr) /* */ { /* 240 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask; /* */ /* 242 */ while (this.used[pos] != 0) { /* 243 */ if (this.key[pos] == k) { /* 244 */ byte oldValue = this.value[pos]; /* */ int tmp49_47 = pos; /* */ byte[] tmp49_44 = this.value; tmp49_44[tmp49_47] = ((byte)(tmp49_44[tmp49_47] + incr)); /* 246 */ return tmp49_47; /* */ } /* 248 */ pos = pos + 1 & this.mask; /* */ } /* 250 */ this.used[pos] = true; /* 251 */ this.key[pos] = k; /* 252 */ this.value[pos] = ((byte)(this.defRetValue + incr)); /* 253 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 255 */ return this.defRetValue; /* */ }
/* */ public Double put(K ok, Double ov) { /* 226 */ double v = ov.doubleValue(); /* 227 */ Object k = ok; /* */ /* 229 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask; /* */ /* 231 */ while (this.used[pos] != 0) { /* 232 */ if (this.strategy.equals(this.key[pos], k)) { /* 233 */ Double oldValue = Double.valueOf(this.value[pos]); /* 234 */ this.value[pos] = v; /* 235 */ return oldValue; /* */ } /* 237 */ pos = pos + 1 & this.mask; /* */ } /* 239 */ this.used[pos] = true; /* 240 */ this.key[pos] = k; /* 241 */ this.value[pos] = v; /* 242 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 244 */ return null; /* */ }
/* */ public Boolean put(Long ok, Boolean ov) { /* 227 */ boolean v = ov.booleanValue(); /* 228 */ long k = ok.longValue(); /* */ /* 230 */ int pos = HashCommon.murmurHash3(this.strategy.hashCode(k)) & this.mask; /* */ /* 232 */ while (this.used[pos] != 0) { /* 233 */ if (this.strategy.equals(this.key[pos], k)) { /* 234 */ Boolean oldValue = Boolean.valueOf(this.value[pos]); /* 235 */ this.value[pos] = v; /* 236 */ return oldValue; /* */ } /* 238 */ pos = pos + 1 & this.mask; /* */ } /* 240 */ this.used[pos] = true; /* 241 */ this.key[pos] = k; /* 242 */ this.value[pos] = v; /* 243 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 245 */ return null; /* */ }
/* */ public Byte put(Long ok, Byte ov) { /* 207 */ byte v = ov.byteValue(); /* 208 */ long k = ok.longValue(); /* */ /* 210 */ int pos = (int)HashCommon.murmurHash3(k) & this.mask; /* */ /* 212 */ while (this.used[pos] != 0) { /* 213 */ if (this.key[pos] == k) { /* 214 */ Byte oldValue = Byte.valueOf(this.value[pos]); /* 215 */ this.value[pos] = v; /* 216 */ return oldValue; /* */ } /* 218 */ pos = pos + 1 & this.mask; /* */ } /* 220 */ this.used[pos] = true; /* 221 */ this.key[pos] = k; /* 222 */ this.value[pos] = v; /* 223 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 225 */ return null; /* */ }
/* */ public Integer put(K ok, Integer ov) { /* 206 */ int v = ov.intValue(); /* 207 */ Object k = ok; /* */ /* 209 */ int pos = (k == null ? 142593372 : HashCommon.murmurHash3(System.identityHashCode(k))) & this.mask; /* */ /* 211 */ while (this.used[pos] != 0) { /* 212 */ if (this.key[pos] == k) { /* 213 */ Integer oldValue = Integer.valueOf(this.value[pos]); /* 214 */ this.value[pos] = v; /* 215 */ return oldValue; /* */ } /* 217 */ pos = pos + 1 & this.mask; /* */ } /* 219 */ this.used[pos] = true; /* 220 */ this.key[pos] = k; /* 221 */ this.value[pos] = v; /* 222 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 224 */ return null; /* */ }
/* */ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { /* 1296 */ s.defaultReadObject(); /* 1297 */ this.n = HashCommon.arraySize(this.size, this.f); /* 1298 */ this.maxFill = HashCommon.maxFill(this.n, this.f); /* 1299 */ this.mask = (this.n - 1); /* 1300 */ long[] key = this.key = new long[this.n]; /* 1301 */ short[] value = this.value = new short[this.n]; /* 1302 */ boolean[] used = this.used = new boolean[this.n]; /* 1303 */ long[] link = this.link = new long[this.n]; /* 1304 */ int prev = -1; /* 1305 */ this.first = (this.last = -1); /* */ /* 1308 */ int i = this.size; for (int pos = 0; i-- != 0; ) { /* 1309 */ long k = s.readLong(); /* 1310 */ short v = s.readShort(); /* 1311 */ pos = (int)HashCommon.murmurHash3(k) & this.mask; /* 1312 */ while (used[pos] != 0) pos = pos + 1 & this.mask; /* 1313 */ used[pos] = true; /* 1314 */ key[pos] = k; /* 1315 */ value[pos] = v; /* 1316 */ if (this.first != -1) { /* 1317 */ link[prev] ^= (link[prev] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF; /* 1318 */ link[pos] ^= (link[pos] ^ (prev & 0xFFFFFFFF) << 32) & 0x0; /* 1319 */ prev = pos; /* */ } /* */ else { /* 1322 */ prev = this.first = pos; /* */ /* 1324 */ link[pos] |= -4294967296L; /* */ } /* */ } /* 1327 */ this.last = prev; /* 1328 */ if (prev != -1) /* */ { /* 1330 */ link[prev] |= 4294967295L; /* */ } /* */ }
/* */ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { /* 1256 */ s.defaultReadObject(); /* 1257 */ this.n = HashCommon.arraySize(this.size, this.f); /* 1258 */ this.maxFill = HashCommon.maxFill(this.n, this.f); /* 1259 */ this.mask = (this.n - 1); /* 1260 */ float[] key = this.key = new float[this.n]; /* 1261 */ char[] value = this.value = new char[this.n]; /* 1262 */ boolean[] used = this.used = new boolean[this.n]; /* 1263 */ long[] link = this.link = new long[this.n]; /* 1264 */ int prev = -1; /* 1265 */ this.first = (this.last = -1); /* */ /* 1268 */ int i = this.size; for (int pos = 0; i-- != 0; ) { /* 1269 */ float k = s.readFloat(); /* 1270 */ char v = s.readChar(); /* 1271 */ pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask; /* 1272 */ while (used[pos] != 0) pos = pos + 1 & this.mask; /* 1273 */ used[pos] = true; /* 1274 */ key[pos] = k; /* 1275 */ value[pos] = v; /* 1276 */ if (this.first != -1) { /* 1277 */ link[prev] ^= (link[prev] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF; /* 1278 */ link[pos] ^= (link[pos] ^ (prev & 0xFFFFFFFF) << 32) & 0x0; /* 1279 */ prev = pos; /* */ } /* */ else { /* 1282 */ prev = this.first = pos; /* */ /* 1284 */ link[pos] |= -4294967296L; /* */ } /* */ } /* 1287 */ this.last = prev; /* 1288 */ if (prev != -1) /* */ { /* 1290 */ link[prev] |= 4294967295L; /* */ } /* */ }
/** * Inserts a value into the set, unless it is already present. * * <p>This function returns the existing value, if present. k * * @param obj Object to insert or retrieve * @return Existing object if already present, or the new object. */ public E addOrGet(E k) { if (k == null) { return null; } // Careful, this is VERSION-DEPENDANT on fastutil, unfortunately. int pos; E curr; final E[] key = this.key; if (!((curr = key[pos = (HashCommon.mix((k).hashCode())) & mask]) == null)) { if (curr.equals(k)) { return curr; } while (!((curr = key[pos = (pos + 1) & mask]) == null)) { if (curr.equals(k)) { return curr; } } } key[pos] = k; if (size++ >= maxFill) { rehash(HashCommon.arraySize(size + 1, f)); } return k; }