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