/** * Removes all of the specified ranges from this range set (optional operation). * * <p>This is equivalent to calling {@link #remove} on each of the ranges in {@code other} in * turn. * * @throws UnsupportedOperationException if this range set does not support the {@code removeAll} * operation * @since 21.0 */ default void removeAll(Iterable<Range<C>> ranges) { for (Range<C> range : ranges) { remove(range); } }
/** * Removes all of the specified ranges from this range set (optional operation). * * <p>This is equivalent to calling {@link #remove} on each of the ranges in {@code other} in * turn. * * @throws UnsupportedOperationException if this range set does not support the {@code removeAll} * operation * @since 21.0 */ default void removeAll(Iterable<Range<C>> ranges) { for (Range<C> range : ranges) { remove(range); } }
@Override public void operationComplete() { if (log.isDebugEnabled()) { log.debug("[{}] Mark delete cursor {} to position {} succeeded", ledger.getName(), name, mdEntry.newPosition); } // Remove from the individual deleted messages all the entries before the new mark delete // point. lock.writeLock().lock(); try { individualDeletedMessages.remove(Range.atMost(mdEntry.newPosition)); } finally { lock.writeLock().unlock(); } ledger.updateCursor(ManagedCursorImpl.this, mdEntry.newPosition); decrementPendingMarkDeleteCount(); // Trigger the final callback after having (eventually) triggered the switchin-ledger operation. This // will ensure that no race condition will happen between the next mark-delete and the switching // operation. if (mdEntry.callbackGroup != null) { // Trigger the callback for every request in the group for (MarkDeleteEntry e : mdEntry.callbackGroup) { e.callback.markDeleteComplete(e.ctx); } } else { // Only trigger the callback for the current request mdEntry.callback.markDeleteComplete(mdEntry.ctx); } }
@GwtIncompatible // SerializableTester public void testSerialization() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.remove(Range.open(5, 7)); SerializableTester.reserializeAndAssert(rangeSet); } }
public void testRemoveUnsupported() { RangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder() .add(Range.closed(5, 8)) .add(Range.closedOpen(1, 3)) .build(); try { rangeSet.remove(Range.closed(6, 7)); fail(); } catch (UnsupportedOperationException expected) { // success } }
public void testRangeContaining2() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.remove(Range.open(5, 7)); assertEquals(Range.closed(3, 5), rangeSet.rangeContaining(5)); assertTrue(rangeSet.contains(5)); assertEquals(Range.closed(7, 10), rangeSet.rangeContaining(8)); assertTrue(rangeSet.contains(8)); assertNull(rangeSet.rangeContaining(6)); assertFalse(rangeSet.contains(6)); }
individualDeletedMessages.remove(Range.atMost(markDeletePosition));
/** * Removes all of the specified ranges from this range set (optional operation). * * <p>This is equivalent to calling {@link #remove} on each of the ranges in {@code other} in * turn. * * @throws UnsupportedOperationException if this range set does not support the {@code removeAll} * operation * @since 21.0 */ default void removeAll(Iterable<Range<C>> ranges) { for (Range<C> range : ranges) { remove(range); } }
/** * Removes all of the specified ranges from this range set (optional operation). * * <p>This is equivalent to calling {@link #remove} on each of the ranges in {@code other} in * turn. * * @throws UnsupportedOperationException if this range set does not support the {@code removeAll} * operation * @since 21.0 */ default void removeAll(Iterable<Range<C>> ranges) { for (Range<C> range : ranges) { remove(range); } }
/** * Remove the RANGE_READ for {@code key} that covers the {@code ranges}. * * @param key * @param ranges */ public void remove(Text key, Iterable<Range<Value>> ranges) { RangeSet<Value> existing = reads.get(key); synchronized (existing) { for (Range<Value> range : ranges) { existing.remove(range); } } }
/** * Remove the {@code range} from {@code key}. * * @param key * @param range */ public void remove(Text key, Range<Value> range) { RangeSet<Value> set = ranges.get(key); set.remove(range); if(set.isEmpty()) { ranges.remove(key); } }
Range<Date> a = Range.closed( new GregorianCalendar(2015, 0, 1).getTime(), new GregorianCalendar(2015, 0, 20).getTime()); Range<Date> b = Range.closed( new GregorianCalendar(2015, 0, 5).getTime(), new GregorianCalendar(2015, 0, 10).getTime()); Range<Date> c = Range.closed( new GregorianCalendar(2015, 0, 11).getTime(), new GregorianCalendar(2015, 0, 14).getTime()); Range<Date> d = Range.closed( new GregorianCalendar(2015, 0, 19).getTime(), new GregorianCalendar(2015, 0, 25).getTime()); RangeSet<Date> result = TreeRangeSet.create(); result.add(a); result.remove(b); result.remove(c); result.add(d); System.out.println(result);
RangeSet<Date> rangeSet = TreeRangeSet.create(); rangeSet.add(referenceRange); for (Range<Date> range : rangesToRemove) { rangeSet.remove(range); } for (Range<Date> exclusiveRange : rangeSet.asRanges()) { ... }
@Override public void operationComplete() { if (log.isDebugEnabled()) { log.debug("[{}] Mark delete cursor {} to position {} succeeded", ledger.getName(), name, mdEntry.newPosition); } // Remove from the individual deleted messages all the entries before the new mark delete // point. lock.writeLock().lock(); try { individualDeletedMessages.remove(Range.atMost(mdEntry.newPosition)); } finally { lock.writeLock().unlock(); } ledger.updateCursor(ManagedCursorImpl.this, mdEntry.newPosition); decrementPendingMarkDeleteCount(); // Trigger the final callback after having (eventually) triggered the switchin-ledger operation. This // will ensure that no race condition will happen between the next mark-delete and the switching // operation. if (mdEntry.callbackGroup != null) { // Trigger the callback for every request in the group for (MarkDeleteEntry e : mdEntry.callbackGroup) { e.callback.markDeleteComplete(e.ctx); } } else { // Only trigger the callback for the current request mdEntry.callback.markDeleteComplete(mdEntry.ctx); } }
/** * Adds the given object defined over the given range where the object is the 'best' * (as defined by the comparator) in the given * @param rs ranges to add to * @param rangeToAdd range to add object to * @param objectToAdd object to add * @param comparator ordering of V used to determine 'best' */ @SuppressWarnings("rawtypes") public static <K extends Comparable, V> void addWhereBest(RangeMap<K, V> rm, Range<K> rangeToAdd, V objectToAdd, Comparator<V> comparator) { RangeSet<K> definedOver = TreeRangeSet.create(); // work out where we should insert definedOver.add(rangeToAdd); for (Entry<Range<K>, V> entry : rm.subRangeMap(rangeToAdd).asMapOfRanges().entrySet()) { if (comparator.compare(entry.getValue(), objectToAdd) >= 0) { definedOver.remove(entry.getKey()); } } // then do the insertion for (Range<K> range : definedOver.asRanges()) { rm.put(range, objectToAdd); } } }
/** * Ensures that portions of the graph exceeding the maximum density are flushed */ private void flushExcessivelyDenseIntervals() { while (!toFlush.isEmpty()) { if (graphByPosition.isEmpty()) break; Range<Integer> range = toFlush.asRanges().iterator().next(); toFlush.remove(range); int flushOnOrAfter = range.lowerEndpoint(); int flushBefore = range.upperEndpoint(); int advanceTo = flushBefore + minDistanceFromNextPositionForEvidenceToBeFullyLoaded(); advanceUnderlying(advanceTo); List<KmerPathSubnode> toRemove = new ArrayList<>(); Iterator<KmerPathNode> it = graphByPosition.descendingIterator(); while (it.hasNext()) { KmerPathNode pn = it.next(); if (pn.firstStart() < flushOnOrAfter) break; if (pn.firstStart() >= flushBefore) continue; toRemove.add(new KmerPathSubnode(pn)); } Set<KmerEvidence> evidenceToRemove = evidenceTracker.untrack(toRemove); if (!evidenceToRemove.isEmpty()) { // it could all overlap our previous flush range removeFromGraph(evidenceToRemove); } } } /**
@GwtIncompatible // SerializableTester public void testSerialization() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.remove(Range.open(5, 7)); SerializableTester.reserializeAndAssert(rangeSet); } }
public void testRemoveUnsupported() { RangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder() .add(Range.closed(5, 8)) .add(Range.closedOpen(1, 3)) .build(); try { rangeSet.remove(Range.closed(6, 7)); fail(); } catch (UnsupportedOperationException expected) { // success } }
private void onVisibleLinesChange(Observable x, Range<Integer> o, Range<Integer> n) { RangeSet<Integer> toUpdate = TreeRangeSet.create(); RangeSet<Integer> toRelease = TreeRangeSet.create(); if (o != null && n != null) { RangeSet<Integer> hidden = TreeRangeSet.create(); hidden.add(o); hidden.remove(n); toRelease.addAll(hidden); } if (n != null) { toUpdate.add(getVisible()); } triggerUpdate(toUpdate); triggerRelease(toRelease); requestLayout(); }
public void testRangeContaining2() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.remove(Range.open(5, 7)); assertEquals(Range.closed(3, 5), rangeSet.rangeContaining(5)); assertTrue(rangeSet.contains(5)); assertEquals(Range.closed(7, 10), rangeSet.rangeContaining(8)); assertTrue(rangeSet.contains(8)); assertNull(rangeSet.rangeContaining(6)); assertFalse(rangeSet.contains(6)); }