@Override public boolean contains(@Nullable Object target) { Object[] table = this.table; if (target == null || table == null) { return false; } for (int i = Hashing.smearedHash(target); ; i++) { i &= mask; Object candidate = table[i]; if (candidate == null) { return false; } else if (candidate.equals(target)) { return true; } } }
@Override public boolean containsKey(@Nullable Object key) { return seekByKey(key, smearedHash(key)) != null; }
@Override public boolean containsValue(@Nullable Object value) { return seekByValue(value, smearedHash(value)) != null; }
@Override public boolean contains(@NullableDecl Object target) { Object[] table = this.table; if (target == null || table == null) { return false; } for (int i = Hashing.smearedHash(target); ; i++) { i &= mask; Object candidate = table[i]; if (candidate == null) { return false; } else if (candidate.equals(target)) { return true; } } }
private int indexOf(@Nullable Object key) { int hash = smearedHash(key); int next = table[hash & hashTableMask()]; while (next != UNSET) { long entry = entries[next]; if (getHash(entry) == hash && Objects.equal(key, keys[next])) { return next; } next = getNext(entry); } return -1; }
@CanIgnoreReturnValue @Override public boolean remove(@Nullable Object object) { return remove(object, smearedHash(object)); }
@Override public boolean contains(@Nullable Object object) { int hash = smearedHash(object); int next = table[hash & hashTableMask()]; while (next != UNSET) { long entry = entries[next]; if (getHash(entry) == hash && Objects.equal(object, elements[next])) { return true; } next = getNext(entry); } return false; }
@Override public int count(@Nullable Object element) { Multisets.ImmutableEntry<E>[] hashTable = this.hashTable; if (element == null || hashTable == null) { return 0; } int hash = Hashing.smearedHash(element); int mask = hashTable.length - 1; for (Multisets.ImmutableEntry<E> entry = hashTable[hash & mask]; entry != null; entry = entry.nextInBucket()) { if (Objects.equal(element, entry.getElement())) { return entry.getCount(); } } return 0; }
@CanIgnoreReturnValue @Override public @Nullable V remove(@Nullable Object key) { return remove(key, smearedHash(key)); }
@Override public @Nullable V get(@Nullable Object key) { return Maps.valueOrNull(seekByKey(key, smearedHash(key))); }
private int indexOf(@NullableDecl Object key) { int hash = smearedHash(key); int next = table[hash & hashTableMask()]; while (next != UNSET) { long entry = entries[next]; if (getHash(entry) == hash && Objects.equal(key, keys[next])) { return next; } next = getNext(entry); } return -1; }
int indexOf(@NullableDecl Object key) { int hash = smearedHash(key); int next = table[hash & hashTableMask()]; while (next != UNSET) { long entry = entries[next]; if (getHash(entry) == hash && Objects.equal(key, keys[next])) { return next; } next = getNext(entry); } return -1; }
@Override public boolean contains(@NullableDecl Object object) { int hash = smearedHash(object); int next = table[hash & hashTableMask()]; while (next != UNSET) { long entry = entries[next]; if (getHash(entry) == hash && Objects.equal(object, elements[next])) { return true; } next = getNext(entry); } return false; }
@CanIgnoreReturnValue public int remove(@NullableDecl Object key) { return remove(key, smearedHash(key)); }
@Override public void remove() { if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
private int indexOf(@NullableDecl Object key) { int hash = smearedHash(key); int next = table[hash & hashTableMask()]; while (next != UNSET) { long entry = entries[next]; if (getHash(entry) == hash && Objects.equal(key, keys[next])) { return next; } next = getNext(entry); } return -1; }
private V put(@Nullable K key, @Nullable V value, boolean force) { int keyHash = smearedHash(key); int valueHash = smearedHash(value); BiEntry<K, V> oldEntryForKey = seekByKey(key, keyHash); if (oldEntryForKey != null && valueHash == oldEntryForKey.valueHash && Objects.equal(value, oldEntryForKey.value)) { return value; } BiEntry<K, V> oldEntryForValue = seekByValue(value, valueHash); if (oldEntryForValue != null) { if (force) { delete(oldEntryForValue); } else { throw new IllegalArgumentException("value already present: " + value); } } BiEntry<K, V> newEntry = new BiEntry<>(key, keyHash, value, valueHash); if (oldEntryForKey != null) { delete(oldEntryForKey); insert(newEntry, oldEntryForKey); oldEntryForKey.prevInKeyInsertionOrder = null; oldEntryForKey.nextInKeyInsertionOrder = null; return oldEntryForKey.value; } else { insert(newEntry, null); rehashIfNecessary(); return null; } }
private @Nullable K putInverse(@Nullable V value, @Nullable K key, boolean force) { int valueHash = smearedHash(value); int keyHash = smearedHash(key);
long[] entries = this.entries; Object[] elements = this.elements; int hash = smearedHash(object); int tableIndex = hash & hashTableMask(); int newEntryIndex = this.size; // current size, and pointer to the entry to be appended
Object[] values = this.values; int hash = smearedHash(key); int tableIndex = hash & hashTableMask(); int newEntryIndex = this.size; // current size, and pointer to the entry to be appended