Refine search
public void testSubSubRangeMap() { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(Range.open(3, 7), 1); rangeMap.put(Range.closed(9, 10), 2); rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub1 = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub1.asMapOfRanges()); RangeMap<Integer, Integer> sub2 = sub1.subRangeMap(Range.open(6, 15)); assertEquals( ImmutableMap.of(Range.open(6, 7), 1, Range.closed(9, 10), 2), sub2.asMapOfRanges()); }
public void testSubRangeMapExhaustive() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(range1, 1); rangeMap.put(range2, 2); RangeMap<Integer, Integer> expected = TreeRangeMap.create(); for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) { if (entry.getKey().isConnected(subRange)) { expected.put(entry.getKey().intersection(subRange), entry.getValue()); RangeMap<Integer, Integer> subRangeMap = rangeMap.subRangeMap(subRange); assertEquals(expected, subRangeMap); assertEquals(expected.asMapOfRanges(), subRangeMap.asMapOfRanges()); assertEquals(expected.asDescendingMapOfRanges(), subRangeMap.asDescendingMapOfRanges()); assertEquals( ImmutableList.copyOf(subRangeMap.asMapOfRanges().entrySet()).reverse(), ImmutableList.copyOf(subRangeMap.asDescendingMapOfRanges().entrySet())); if (!expected.asMapOfRanges().isEmpty()) { assertEquals(expected.span(), subRangeMap.span()); assertEquals(expected.get(i), subRangeMap.get(i)); expected.asMapOfRanges().get(query), subRangeMap.asMapOfRanges().get(query));
private void verify(Map<Integer, Integer> model, RangeMap<Integer, Integer> test) { for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) { assertEquals(model.get(i), test.get(i)); Entry<Range<Integer>, Integer> entry = test.getEntry(i); assertEquals(model.containsKey(i), entry != null); if (entry != null) { assertTrue(test.asMapOfRanges().entrySet().contains(entry)); } } for (Range<Integer> range : test.asMapOfRanges().keySet()) { assertFalse(range.isEmpty()); } }
@Override public Map<Range<Integer>, String> create(Object... elements) { RangeMap<Integer, String> rangeMap = TreeRangeMap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<Range<Integer>, String> entry = (Entry<Range<Integer>, String>) o; rangeMap.put(entry.getKey(), entry.getValue()); } return rangeMap.subRangeMap(Range.atMost(22)).asMapOfRanges(); }
@Override public Map<Range<Integer>, String> create(Object... elements) { RangeMap<Integer, String> rangeMap = TreeRangeMap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<Range<Integer>, String> entry = (Entry<Range<Integer>, String>) o; rangeMap.put(entry.getKey(), entry.getValue()); } return rangeMap.subRangeMap(Range.atMost(22)).asDescendingMapOfRanges(); }
@Override public Map<Range<Integer>, String> create(Object... elements) { RangeMap<Integer, String> rangeMap = TreeRangeMap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<Range<Integer>, String> entry = (Entry<Range<Integer>, String>) o; rangeMap.put(entry.getKey(), entry.getValue()); } return rangeMap.asDescendingMapOfRanges(); }
if(range.isEmpty()) { Range<Long> lookupRange = range.intersection(cacheRange); RangeMap<Long, CacheEntry<T>> subMap = rangesToData.subRangeMap(lookupRange); Long offset = range.lowerEndpoint(); for(Entry<Range<Long>, CacheEntry<T>> e : subMap.asMapOfRanges().entrySet()) {
private void checkOverlaps(Replacement replacement) { Range<Integer> replacementRange = replacement.range(); Collection<Replacement> overlap = overlaps.subRangeMap(replacementRange).asMapOfRanges().values(); checkArgument( overlap.isEmpty(), "%s overlaps with existing replacements: %s", replacement, Joiner.on(", ").join(overlap)); Set<Integer> containedZeroLengthRangeStarts = zeroLengthRanges.subSet( replacementRange.lowerEndpoint(), /* fromInclusive= */ false, replacementRange.upperEndpoint(), /* toInclusive= */ false); checkArgument( containedZeroLengthRangeStarts.isEmpty(), "%s overlaps with existing zero-length replacements: %s", replacement, Joiner.on(", ").join(containedZeroLengthRangeStarts)); overlaps.put(replacementRange, replacement); if (replacementRange.isEmpty()) { zeroLengthRanges.add(replacementRange.lowerEndpoint()); } }
for (Map.Entry<Range<Integer>, String> replacement : replacements.asMapOfRanges().entrySet()) { Range<Integer> range = replacement.getKey(); String replaceWith = replacement.getValue(); int start = offset + range.lowerEndpoint(); int end = offset + range.upperEndpoint(); sb.replace(start, end, replaceWith); if (!replaceWith.isEmpty()) { fixedRanges.add(Range.closedOpen(start, end)); offset += replaceWith.length() - (range.upperEndpoint() - range.lowerEndpoint());
public void testSubRangeMapClear() { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(Range.open(3, 7), 1); rangeMap.put(Range.closed(9, 10), 2); rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); sub.clear(); assertEquals( ImmutableMap.of(Range.open(3, 5), 1, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); }
@Test public void testTokenMapping() { Map<Range<LightweightOppToken>, List<InetSocketAddress>> mapOfRanges = clientPool.getTokenMap().asMapOfRanges(); assertFalse(mapOfRanges.isEmpty()); for (Entry<Range<LightweightOppToken>, List<InetSocketAddress>> entry : mapOfRanges.entrySet()) { Range<LightweightOppToken> tokenRange = entry.getKey(); List<InetSocketAddress> hosts = entry.getValue(); clientPool.getRandomHostForKey("A".getBytes(StandardCharsets.UTF_8)); if (tokenRange.hasLowerBound()) { assertTrue(hosts.contains(clientPool.getRandomHostForKey(tokenRange.lowerEndpoint().bytes))); } if (tokenRange.hasUpperBound()) { assertTrue(hosts.contains(clientPool.getRandomHostForKey(tokenRange.upperEndpoint().bytes))); } } }
boolean isOffsetInRequestRange = canonicalRequestRange.contains(offset); if(!isOffsetInRequestRange) { e = rangeMap.getEntry(offset); Range<Long> r = Range.atLeast(offset).intersection(canonicalRequestRange); boolean cancelled[] = {false}; Flowable<T> stream = delegate.apply(r)
public ShardState lookupBucketTable(Range<Integer> range) { Map<Range<Integer>, ShardState> rangeMaps = bucketMap.subRangeMap(range).asMapOfRanges(); if (rangeMaps.size() > 1) { boolean same = true; ShardState prev = null; for (Map.Entry<Range<Integer>, ShardState> e : rangeMaps.entrySet()) { Range<Integer> r = e.getKey(); if (r.upperEndpoint() - r.lowerEndpoint() <= 1 && r.lowerBoundType() == BoundType.OPEN && r.upperBoundType() == BoundType.OPEN) { continue; } if (prev != null && !prev.equals(e.getValue())) { same = false; break; } prev = e.getValue(); } if (!same) { throw new IllegalStateException( "Overlapped range found - inputRange=" + range + " ranges=" + rangeMaps.toString()); } return prev; } else if (rangeMaps.size() == 0) { return null; } return rangeMaps.values().stream().findFirst().get(); }
public void testPutCoalescing() { // {[0..1): 1, [1..2): 1, [2..3): 2} -> {[0..2): 1, [2..3): 2} RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.putCoalescing(Range.closedOpen(0, 1), 1); rangeMap.putCoalescing(Range.closedOpen(1, 2), 1); rangeMap.putCoalescing(Range.closedOpen(2, 3), 2); assertEquals( ImmutableMap.of(Range.closedOpen(0, 2), 1, Range.closedOpen(2, 3), 2), rangeMap.asMapOfRanges()); }
private static RangeMap<Integer, RepeatMaskerRepeat> toLookup(List<RepeatMaskerRepeat> repeatList) throws IOException { RangeMap<Integer, RepeatMaskerRepeat> elements = TreeRangeMap.create(); for (RepeatMaskerRepeat repeat : repeatList) { elements.put(Range.closed(repeat.begin, repeat.end), repeat); } return elements; } @Override
@Override public void initialize(Arguments args) throws DirectiveParseException { this.col1 = ((ColumnName) args.value("source")).value(); this.col2 = ((ColumnName) args.value("destination")).value(); List<Triplet<Numeric, Numeric, String>> ranges = ((Ranges) args.value("ranges")).value(); for (Triplet<Numeric, Numeric, String> range : ranges) { double lower = range.getFirst().value().doubleValue(); double upper = range.getSecond().value().doubleValue(); rangeMap.put(Range.closed(lower, upper), range.getThird()); } }
Range<Long> dataRange = Range.closedOpen(0l, dataThreshold); range = range.intersection(dataRange); RangeMap<Long, CacheEntry<T>> subRangeMap = rangesToData.subRangeMap(range); Map<Range<Long>, CacheEntry<T>> x = subRangeMap.asMapOfRanges(); CacheEntry<T> ce = entry.getValue(); boolean isEnclosing = ce.range.encloses(range);
Set<String> usedNames, Multimap<String, Range<Integer>> usedInJavadoc) { RangeMap<Integer, String> replacements = TreeRangeMap.create(); for (JCImport importTree : unit.getImports()) { String simpleName = getSimpleName(importTree); endPosition += sep.length(); replacements.put(Range.closedOpen(importTree.getStartPosition(), endPosition), ""); replacements.put(docRange, replaceWith);
String onlyEndpoint = Iterables.getOnlyElement(Iterables.getOnlyElement(tokenRanges).getEndpoints()); InetSocketAddress onlyHost = getAddressForHost(onlyEndpoint); newTokenRing.put(Range.all(), ImmutableList.of(onlyHost)); servers.add(onlyHost); } else { // normal case, large cluster with many vnodes BaseEncoding.base16().decode(tokenRange.getEnd_token().toUpperCase())); if (startToken.compareTo(endToken) <= 0) { newTokenRing.put(Range.openClosed(startToken, endToken), hosts); } else { newTokenRing.put(Range.greaterThan(startToken), hosts); newTokenRing.put(Range.atMost(endToken), hosts); return tokenMap.asMapOfRanges().values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
@Override public VariantEvidenceSupport findBestOverlapping(BreakendSummary breakend) { if (breakend instanceof BreakpointSummary) { return findBestOverlapping((BreakpointSummary)breakend); } // lookup bestLocal RangeMap<Integer, VariantEvidenceSupport> rm = bestLocal.get(getIndex(breakend.referenceIndex, breakend.direction)); rm = rm.subRangeMap(Range.closedOpen(breakend.start, breakend.end + 1)); float bestScore = -1; VariantEvidenceSupport best = null; for (VariantEvidenceSupport entry : rm.asMapOfRanges().values()) { if (entry.score > bestScore) { bestScore = entry.score; best = entry; } } return best; } }