/* */ 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 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 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 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;
/* */ }
/**
* Returns the hash code for this big list, which is identical to {@link
* java.util.List#hashCode()}.
*
* @return the hash code for this big list.
*/
public int hashCode() {
FloatIterator i = iterator();
int h = 1;
long s = size64();
while (s-- != 0) {
float k = i.nextFloat();
h = 31 * h + it.unimi.dsi.fastutil.HashCommon.float2int(k);
}
return h;
}
/* */ 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 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;
/* */ }
/**
* Returns a hash code for this map.
*
* <p>This method overrides the generic method provided by the superclass. Since <code>equals()
* </code> is not overriden, it is important that the value returned by this method is the same
* value as the one returned by the overriden method.
*
* @return a hash code for this map.
*/
public int hashCode() {
int h = 0;
for (int j = size, i = 0, t = 0; j-- != 0; ) {
while (!used[i]) i++;
t = it.unimi.dsi.fastutil.HashCommon.long2int(key[i]);
t ^= it.unimi.dsi.fastutil.HashCommon.float2int(value[i]);
h += t;
i++;
}
return h;
}
/* */ public Character get(Float ok) {
/* 544 */ float k = ok.floatValue();
/* */
/* 546 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask;
/* */
/* 548 */ while (this.used[pos] != 0) {
/* 549 */ if (this.key[pos] == k) return Character.valueOf(this.value[pos]);
/* 550 */ pos = pos + 1 & this.mask;
/* */ }
/* 552 */ return null;
/* */ }
/* */ public int hashCode()
/* */ {
/* 1233 */ int h = 0;
/* 1234 */ int j = this.size; int i = 0; for (int t = 0; j-- != 0; ) {
/* 1235 */ while (this.used[i] == 0) i++;
/* 1236 */ t = HashCommon.float2int(this.key[i]);
/* 1237 */ t ^= this.value[i];
/* 1238 */ h += t;
/* 1239 */ i++;
/* */ }
/* 1241 */ return h;
/* */ }
/* */ public boolean contains(Object o) {
/* 942 */ if (!(o instanceof Map.Entry)) return false;
/* 943 */ Map.Entry e = (Map.Entry)o;
/* 944 */ float k = ((Float)e.getKey()).floatValue();
/* */
/* 946 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & Float2CharLinkedOpenHashMap.this.mask;
/* */
/* 948 */ while (Float2CharLinkedOpenHashMap.this.used[pos] != 0) {
/* 949 */ if (Float2CharLinkedOpenHashMap.this.key[pos] == k) return Float2CharLinkedOpenHashMap.this.value[pos] == ((Character)e.getValue()).charValue();
/* 950 */ pos = pos + 1 & Float2CharLinkedOpenHashMap.this.mask;
/* */ }
/* 952 */ return false;
/* */ }
/* */ public char remove(float k)
/* */ {
/* 319 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask;
/* */
/* 321 */ while (this.used[pos] != 0) {
/* 322 */ if (this.key[pos] == k) {
/* 323 */ this.size -= 1;
/* 324 */ fixPointers(pos);
/* 325 */ char v = this.value[pos];
/* 326 */ shiftKeys(pos);
/* 327 */ return v;
/* */ }
/* 329 */ pos = pos + 1 & this.mask;
/* */ }
/* 331 */ return this.defRetValue;
/* */ }
/* */ public boolean remove(Object o) {
/* 956 */ if (!(o instanceof Map.Entry)) return false;
/* 957 */ Map.Entry e = (Map.Entry)o;
/* 958 */ float k = ((Float)e.getKey()).floatValue();
/* */
/* 960 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & Float2CharLinkedOpenHashMap.this.mask;
/* */
/* 962 */ while (Float2CharLinkedOpenHashMap.this.used[pos] != 0) {
/* 963 */ if (Float2CharLinkedOpenHashMap.this.key[pos] == k) {
/* 964 */ Float2CharLinkedOpenHashMap.this.remove(e.getKey());
/* 965 */ return true;
/* */ }
/* 967 */ pos = pos + 1 & Float2CharLinkedOpenHashMap.this.mask;
/* */ }
/* 969 */ return false;
/* */ }
/* */ protected void rehash(int newN)
/* */ {
/* 1154 */ int i = this.first; int prev = -1; int newPrev = -1;
/* */
/* 1156 */ float[] key = this.key;
/* 1157 */ char[] value = this.value;
/* 1158 */ int newMask = newN - 1;
/* 1159 */ float[] newKey = new float[newN];
/* 1160 */ char[] newValue = new char[newN];
/* 1161 */ boolean[] newUsed = new boolean[newN];
/* 1162 */ long[] link = this.link;
/* 1163 */ long[] newLink = new long[newN];
/* 1164 */ this.first = -1;
/* 1165 */ for (int j = this.size; j-- != 0; ) {
/* 1166 */ float k = key[i];
/* 1167 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & newMask;
/* 1168 */ while (newUsed[pos] != 0) pos = pos + 1 & newMask;
/* 1169 */ newUsed[pos] = true;
/* 1170 */ newKey[pos] = k;
/* 1171 */ newValue[pos] = value[i];
/* 1172 */ if (prev != -1) {
/* 1173 */ newLink[newPrev] ^= (newLink[newPrev] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 1174 */ newLink[pos] ^= (newLink[pos] ^ (newPrev & 0xFFFFFFFF) << 32) & 0x0;
/* 1175 */ newPrev = pos;
/* */ }
/* */ else {
/* 1178 */ newPrev = this.first = pos;
/* */
/* 1180 */ newLink[pos] = -1L;
/* */ }
/* 1182 */ int t = i;
/* 1183 */ i = (int)link[i];
/* 1184 */ prev = t;
/* */ }
/* 1186 */ this.n = newN;
/* 1187 */ this.mask = newMask;
/* 1188 */ this.maxFill = HashCommon.maxFill(this.n, this.f);
/* 1189 */ this.key = newKey;
/* 1190 */ this.value = newValue;
/* 1191 */ this.used = newUsed;
/* 1192 */ this.link = newLink;
/* 1193 */ this.last = newPrev;
/* 1194 */ if (newPrev != -1)
/* */ {
/* 1196 */ newLink[newPrev] |= 4294967295L;
/* */ }
/* */ }
/* */ public Character remove(Object ok) {
/* 335 */ float k = ((Float)ok).floatValue();
/* */
/* 337 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask;
/* */
/* 339 */ while (this.used[pos] != 0) {
/* 340 */ if (this.key[pos] == k) {
/* 341 */ this.size -= 1;
/* 342 */ fixPointers(pos);
/* 343 */ char v = this.value[pos];
/* 344 */ shiftKeys(pos);
/* 345 */ return Character.valueOf(v);
/* */ }
/* 347 */ pos = pos + 1 & this.mask;
/* */ }
/* 349 */ return null;
/* */ }
/* */ public char getAndMoveToFirst(float k)
/* */ {
/* 429 */ float[] key = this.key;
/* 430 */ boolean[] used = this.used;
/* 431 */ int mask = this.mask;
/* */
/* 433 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & mask;
/* */
/* 435 */ while (used[pos] != 0) {
/* 436 */ if (k == key[pos]) {
/* 437 */ moveIndexToFirst(pos);
/* 438 */ return this.value[pos];
/* */ }
/* 440 */ pos = pos + 1 & mask;
/* */ }
/* 442 */ return this.defRetValue;
/* */ }
/* */ public char getAndMoveToLast(float k)
/* */ {
/* 450 */ float[] key = this.key;
/* 451 */ boolean[] used = this.used;
/* 452 */ int mask = this.mask;
/* */
/* 454 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & mask;
/* */
/* 456 */ while (used[pos] != 0) {
/* 457 */ if (k == key[pos]) {
/* 458 */ moveIndexToLast(pos);
/* 459 */ return this.value[pos];
/* */ }
/* 461 */ pos = pos + 1 & mask;
/* */ }
/* 463 */ return this.defRetValue;
/* */ }
/* */ protected final int shiftKeys(int pos)
/* */ {
/* */ int last;
/* */ while (true)
/* */ {
/* 302 */ pos = (last = pos) + 1 & this.mask;
/* 303 */ while (this.used[pos] != 0) {
/* 304 */ int slot = HashCommon.murmurHash3(HashCommon.float2int(this.key[pos])) & this.mask;
/* 305 */ if (last <= pos ? (last < slot) && (slot <= pos) : (last >= slot) && (slot > pos)) break;
/* 306 */ pos = pos + 1 & this.mask;
/* */ }
/* 308 */ if (this.used[pos] == 0) break;
/* 309 */ this.key[last] = this.key[pos];
/* 310 */ this.value[last] = this.value[pos];
/* 311 */ fixPointers(pos, last);
/* */ }
/* 313 */ this.used[last] = false;
/* 314 */ return last;
/* */ }
/* */ private MapIterator(float from) {
/* 769 */ if (Float2CharLinkedOpenHashMap.this.key[Float2CharLinkedOpenHashMap.this.last] == from) {
/* 770 */ this.prev = Float2CharLinkedOpenHashMap.this.last;
/* 771 */ this.index = Float2CharLinkedOpenHashMap.this.size;
/* */ }
/* */ else
/* */ {
/* 775 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(from)) & Float2CharLinkedOpenHashMap.this.mask;
/* */
/* 777 */ while (Float2CharLinkedOpenHashMap.this.used[pos] != 0) {
/* 778 */ if (Float2CharLinkedOpenHashMap.this.key[pos] == from)
/* */ {
/* 780 */ this.next = ((int)Float2CharLinkedOpenHashMap.this.link[pos]);
/* 781 */ this.prev = pos;
/* 782 */ return;
/* */ }
/* 784 */ pos = pos + 1 & Float2CharLinkedOpenHashMap.this.mask;
/* */ }
/* 786 */ throw new NoSuchElementException("The key " + from + " does not belong to this map.");
/* */ }
/* */ }
/* */ 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;
/* */ }
/* */ }
/* */ public void remove() {
/* 834 */ ensureIndexKnown();
/* 835 */ if (this.curr == -1) throw new IllegalStateException();
/* 836 */ if (this.curr == this.prev)
/* */ {
/* 839 */ this.index -= 1;
/* 840 */ this.prev = ((int)(Float2CharLinkedOpenHashMap.this.link[this.curr] >>> 32));
/* */ }
/* */ else {
/* 843 */ this.next = ((int)Float2CharLinkedOpenHashMap.this.link[this.curr]);
/* 844 */ }Float2CharLinkedOpenHashMap.this.size -= 1;
/* */
/* 847 */ if (this.prev == -1) Float2CharLinkedOpenHashMap.this.first = this.next;
/* */ else
/* 849 */ Float2CharLinkedOpenHashMap.this.link[this.prev] ^= (Float2CharLinkedOpenHashMap.this.link[this.prev] ^ this.next & 0xFFFFFFFF) & 0xFFFFFFFF;
/* 850 */ if (this.next == -1) Float2CharLinkedOpenHashMap.this.last = this.prev;
/* */ else
/* 852 */ Float2CharLinkedOpenHashMap.this.link[this.next] ^= (Float2CharLinkedOpenHashMap.this.link[this.next] ^ (this.prev & 0xFFFFFFFF) << 32) & 0x0; int pos = this.curr;
/* */ int last;
/* */ while (true) {
/* 856 */ pos = (last = pos) + 1 & Float2CharLinkedOpenHashMap.this.mask;
/* 857 */ while (Float2CharLinkedOpenHashMap.this.used[pos] != 0) {
/* 858 */ int slot = HashCommon.murmurHash3(HashCommon.float2int(Float2CharLinkedOpenHashMap.this.key[pos])) & Float2CharLinkedOpenHashMap.this.mask;
/* 859 */ if (last <= pos ? (last < slot) && (slot <= pos) : (last >= slot) && (slot > pos)) break;
/* 860 */ pos = pos + 1 & Float2CharLinkedOpenHashMap.this.mask;
/* */ }
/* 862 */ if (Float2CharLinkedOpenHashMap.this.used[pos] == 0) break;
/* 863 */ Float2CharLinkedOpenHashMap.this.key[last] = Float2CharLinkedOpenHashMap.this.key[pos];
/* 864 */ Float2CharLinkedOpenHashMap.this.value[last] = Float2CharLinkedOpenHashMap.this.value[pos];
/* 865 */ if (this.next == pos) this.next = last;
/* 866 */ if (this.prev == pos) this.prev = last;
/* 867 */ Float2CharLinkedOpenHashMap.this.fixPointers(pos, last);
/* */ }
/* 869 */ Float2CharLinkedOpenHashMap.this.used[last] = false;
/* 870 */ this.curr = -1;
/* */ }
public int hashCode() {
return it.unimi.dsi.fastutil.HashCommon.long2int(key[index])
^ it.unimi.dsi.fastutil.HashCommon.float2int(value[index]);
}
public int hashCode() {
return ((key) == null ? 0 : (key).hashCode())
^ it.unimi.dsi.fastutil.HashCommon.float2int(value);
}
/* */ public int hashCode() {
/* 655 */ return HashCommon.float2int(Float2CharLinkedOpenHashMap.this.key[this.index]) ^ Float2CharLinkedOpenHashMap.this.value[this.index];
/* */ }
