@Override public boolean remove(Object o) { return this.delegatee.remove(o) != null; }
private void decrementBitmapOfSize(Integer size) { Integer current = sortedSizes.get(size); if (current == 1) { sortedSizes.remove(size); } else { sortedSizes.put(size, current - 1); } }
private void replaceRangeWithSameLowerBound(Range<C> range) { if (range.isEmpty()) { rangesByLowerBound.remove(range.lowerBound); } else { rangesByLowerBound.put(range.lowerBound, range); } }
/** * Removes an occurrence of the specified object from this {@code TreeSet}. * * @param object * the object to remove. * @return {@code true} if this {@code TreeSet} was modified, {@code false} * otherwise. * @throws ClassCastException * when the object cannot be compared with the elements in this * {@code TreeSet}. * @throws NullPointerException * when the object is null and the comparator cannot handle * null. */ @Override public boolean remove(Object object) { return backingMap.remove(object) != null; }
@Override public V remove(Object key) { return delegate.remove(checkValid(key)); }
/** * @param absIdx Reserved index. */ synchronized void release(long absIdx) { Integer cur = reserved.get(absIdx); assert cur != null && cur >= 1 : "cur=" + cur + ", absIdx=" + absIdx; if (cur == 1) reserved.remove(absIdx); else reserved.put(absIdx, cur - 1); } }
private void decrementArrayOfSize(int size, Class<?> arrayClass) { NavigableMap<Integer, Integer> sizes = getSizesForAdapter(arrayClass); Integer current = sizes.get(size); if (current == null) { throw new NullPointerException( "Tried to decrement empty size" + ", size: " + size + ", this: " + this); } if (current == 1) { sizes.remove(size); } else { sizes.put(size, current - 1); } }
private void replaceRangeWithSameLowerBound(Range<C> range) { if (range.isEmpty()) { rangesByLowerBound.remove(range.lowerBound); } else { rangesByLowerBound.put(range.lowerBound, range); } }
private void replaceRangeWithSameLowerBound(Range<C> range) { if (range.isEmpty()) { rangesByLowerBound.remove(range.lowerBound); } else { rangesByLowerBound.put(range.lowerBound, range); } }
private void decrementBitmapOfSize(Integer size, Bitmap removed) { Bitmap.Config config = removed.getConfig(); NavigableMap<Integer, Integer> sizes = getSizesForConfig(config); Integer current = sizes.get(size); if (current == null) { throw new NullPointerException("Tried to decrement empty size" + ", size: " + size + ", removed: " + logBitmap(removed) + ", this: " + this); } if (current == 1) { sizes.remove(size); } else { sizes.put(size, current - 1); } }
private void replaceRangeWithSameLowerBound(Range<C> range) { if (range.isEmpty()) { rangesByLowerBound.remove(range.lowerBound); } else { rangesByLowerBound.put(range.lowerBound, range); } }
public void ack(long id) { forward_table.remove(id); ack_promise.setResult(id); // lock acquition, but most of the times it is uncontended, so this is not a cost }
private void remove( NavigableMap<Interval, TimelineEntry> timeline, Interval interval, boolean incompleteOk ) { timeline.remove(interval); for (Map.Entry<Interval, TreeMap<VersionType, TimelineEntry>> versionEntry : allTimelineEntries.entrySet()) { if (versionEntry.getKey().overlap(interval) != null) { if (incompleteOk) { add(timeline, versionEntry.getKey(), versionEntry.getValue().lastEntry().getValue()); } else { for (VersionType ver : versionEntry.getValue().descendingKeySet()) { TimelineEntry timelineEntry = versionEntry.getValue().get(ver); if (timelineEntry.getPartitionHolder().isComplete()) { add(timeline, versionEntry.getKey(), timelineEntry); break; } } } } } }
@Override public void rollback() { LOG.debug("rollback"); try { if (existsRow(prepareNamespace)) { deleteRow(prepareNamespace); } else { LOG.debug("Nothing to rollback, prepared data is empty"); } Long lastCommittedId = lastCommittedTxid(); if (lastCommittedId != null) { txIds.put(PREPARE_TXID_KEY, String.valueOf(lastCommittedId).getBytes()); } else { txIds.remove(PREPARE_TXID_KEY); } if (!txIds.isEmpty()) { LOG.debug("put txidNamespace {}, txIds {}", txidNamespace, txIds); mutateRow(txidNamespace, columnFamily, txIds); } pendingCommit = EMPTY_PENDING_COMMIT_MAP; pendingPrepare = createPendingPrepareMap(); } catch (Exception e) { throw new RuntimeException(e); } }
/** * Clears checkpoint history after WAL truncation. * * @return List of checkpoint entries removed from history. */ public List<CheckpointEntry> onWalTruncated(WALPointer ptr) { List<CheckpointEntry> removed = new ArrayList<>(); FileWALPointer highBound = (FileWALPointer)ptr; for (CheckpointEntry cpEntry : histMap.values()) { FileWALPointer cpPnt = (FileWALPointer)cpEntry.checkpointMark(); if (highBound.compareTo(cpPnt) <= 0) break; if (cctx.wal().reserved(cpEntry.checkpointMark())) { U.warn(log, "Could not clear historyMap due to WAL reservation on cp: " + cpEntry + ", history map size is " + histMap.size()); break; } histMap.remove(cpEntry.timestamp()); removed.add(cpEntry); } return removed; }
/** * Removes a segment. * * @param segment The segment to remove. */ synchronized void removeSegment(JournalSegment segment) { segments.remove(segment.index()); segment.close(); segment.delete(); resetCurrentSegment(); }
@GwtIncompatible // NavigableMap public void testAsMapNavigableWritesThrough() { NavigableSet<String> strings = Sets.newTreeSet(); Collections.addAll(strings, "one", "two", "three"); NavigableMap<String, Integer> map = Maps.asMap(strings, LENGTH_FUNCTION); assertEquals(ImmutableMap.of("one", 3, "two", 3, "three", 5), map); assertEquals(Integer.valueOf(3), map.remove("two")); assertThat(strings).containsExactly("one", "three").inOrder(); assertEquals(mapEntry("three", 5), map.subMap("one", false, "zzz", true).pollLastEntry()); assertThat(strings).contains("one"); }
public void testStandardLastEntry() { NavigableMap<String, Integer> forwarding = new StandardLastEntryForwardingNavigableMap<>(new SafeTreeMap<String, Integer>()); assertNull(forwarding.lastEntry()); forwarding.put("b", 2); assertEquals(immutableEntry("b", 2), forwarding.lastEntry()); forwarding.put("c", 3); assertEquals(immutableEntry("c", 3), forwarding.lastEntry()); forwarding.put("a", 1); assertEquals(immutableEntry("c", 3), forwarding.lastEntry()); forwarding.remove("c"); assertEquals(immutableEntry("b", 2), forwarding.lastEntry()); }
@GwtIncompatible // NavigableMap void ensureNotDirectlyModifiable(NavigableMap<Integer, String> unmod) { try { unmod.put(4, "four"); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } try { unmod.putAll(Collections.singletonMap(4, "four")); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } try { unmod.remove(4); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } try { unmod.pollFirstEntry(); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } try { unmod.pollLastEntry(); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } }
private void updateMutationAddingTags(final Mutation m) { byte[] attribute = m.getAttribute("visibility"); byte[] cf = null; List<Cell> updatedCells = new ArrayList<>(); if (attribute != null) { for (List<? extends Cell> edits : m.getFamilyCellMap().values()) { for (Cell cell : edits) { KeyValue kv = KeyValueUtil.ensureKeyValue(cell); if (cf == null) { cf = CellUtil.cloneFamily(kv); } Tag tag = new ArrayBackedTag((byte) 1, attribute); List<Tag> tagList = new ArrayList<>(); tagList.add(tag); KeyValue newKV = new KeyValue(CellUtil.cloneRow(kv), 0, kv.getRowLength(), CellUtil.cloneFamily(kv), 0, kv.getFamilyLength(), CellUtil.cloneQualifier(kv), 0, kv.getQualifierLength(), kv.getTimestamp(), KeyValue.Type.codeToType(kv.getTypeByte()), CellUtil.cloneValue(kv), 0, kv.getValueLength(), tagList); ((List<Cell>) updatedCells).add(newKV); } } m.getFamilyCellMap().remove(cf); // Update the family map m.getFamilyCellMap().put(cf, updatedCells); } }