@Override public void remove() { if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
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; } }
@Override public void remove() { if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
private V put(@NullableDecl K key, @NullableDecl 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; } }
@Override public void remove() { checkForConcurrentModification(); checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { checkForConcurrentModification(); checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { checkForConcurrentModification(); checkState(toRemove != null, "Only one remove() call allowed per call to next"); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { checkForConcurrentModification(); checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { checkForConcurrentModification(); checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { checkForConcurrentModification(); checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { checkForConcurrentModification(); checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Nullable private K putInverse(@Nullable V value, @Nullable K key, boolean force) { int valueHash = hash(value); int keyHash = hash(key); BiEntry<K, V> oldEntryForValue = seekByValue(value, valueHash); if (oldEntryForValue != null && keyHash == oldEntryForValue.keyHash && Objects.equal(key, oldEntryForValue.key)) { return key; } BiEntry<K, V> oldEntryForKey = seekByKey(key, keyHash); if (oldEntryForKey != null) { if (force) { delete(oldEntryForKey); } else { throw new IllegalArgumentException("value already present: " + key); } } if (oldEntryForValue != null) { delete(oldEntryForValue); } BiEntry<K, V> newEntry = new BiEntry<K, V>(key, keyHash, value, valueHash); insert(newEntry); rehashIfNecessary(); return (oldEntryForValue == null) ? null : oldEntryForValue.key; }
private V put(@Nullable K key, @Nullable V value, boolean force) { int keyHash = hash(key); int valueHash = hash(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); } } if (oldEntryForKey != null) { delete(oldEntryForKey); } BiEntry<K, V> newEntry = new BiEntry<K, V>(key, keyHash, value, valueHash); insert(newEntry); rehashIfNecessary(); return (oldEntryForKey == null) ? null : oldEntryForKey.value; }
private V put(@Nullable K key, @Nullable V value, boolean force) { int keyHash = hash(key); int valueHash = hash(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); } } if (oldEntryForKey != null) { delete(oldEntryForKey); } BiEntry<K, V> newEntry = new BiEntry<K, V>(key, keyHash, value, valueHash); insert(newEntry); rehashIfNecessary(); return (oldEntryForKey == null) ? null : oldEntryForKey.value; }
private V put(@Nullable K key, @Nullable V value, boolean force) { int keyHash = hash(key); int valueHash = hash(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); } } if (oldEntryForKey != null) { delete(oldEntryForKey); } BiEntry<K, V> newEntry = new BiEntry<K, V>(key, keyHash, value, valueHash); insert(newEntry); rehashIfNecessary(); return (oldEntryForKey == null) ? null : oldEntryForKey.value; }
@Override public void remove() { if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }
@Override public void remove() { if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } checkRemove(toRemove != null); delete(toRemove); expectedModCount = modCount; toRemove = null; }