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()); } }
@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.subRangeMap(Range.atMost(22)).asMapOfRanges(); }
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 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()); }
public void testSubRangeMapRemove() { 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)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub.remove(Range.closed(7, 9)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 7), 1, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); sub.remove(Range.closed(3, 9)); assertEquals(ImmutableMap.of(Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 5), 1, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); }
rangeMap.put(Range.closed(9, 10), 2); rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges());
rangeMap.put(Range.closed(9, 10), 2); rangeMap.put(Range.closed(12, 16), 3); RangeMap<Integer, Integer> sub = rangeMap.subRangeMap(Range.closed(5, 11)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub = sub.subRangeMap(Range.closedOpen(5, 5)); sub.put(Range.closedOpen(5, 5), 6); // should be a no-op assertEquals(
RangeMap<Integer, Integer> subRangeMap = rangeMap.subRangeMap(subRange); assertEquals(expected, subRangeMap); assertEquals(expected.asMapOfRanges(), subRangeMap.asMapOfRanges());
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(); }
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()); } }
@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; } }
/** * 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); } } }
/** * Determins where offset in the given evidence is included in the assembly. * Read pairs can overlap multiple times if the sequence kmer is repeated. * Since we don't actually know which position we placed the read in, we'll return them all. */ private Collection<Integer> getContigBaseOffsetFor(Long2ObjectOpenHashMap<RangeMap<Integer,Integer>> lookup, KmerEvidence e, int evidenceOffset) { KmerSupportNode node = e.node(evidenceOffset); if (node != null) { long kmer = node.firstKmer(); RangeMap<Integer, Integer> lookupEntry = lookup.get(kmer); if (lookupEntry != null) { Map<Range<Integer>, Integer> matching = lookupEntry.subRangeMap(Range.closedOpen(node.firstStart(), node.firstEnd() + 1)).asMapOfRanges(); if (!matching.isEmpty()) { return matching.values(); } } } return Collections.emptyList(); } private Range<Integer> contigBaseOffsetBounds(Long2ObjectOpenHashMap<RangeMap<Integer,Integer>> lookup, KmerEvidence e) {
@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(); }
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 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()); }
public void testSubRangeMapPut() { 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)); assertEquals(ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub.put(Range.closed(7, 9), 4); assertEquals( ImmutableMap.of( Range.closedOpen(5, 7), 1, Range.closed(7, 9), 4, Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 7), 1, Range.closed(7, 9), 4, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); try { sub.put(Range.open(9, 12), 5); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } sub = sub.subRangeMap(Range.closedOpen(5, 5)); sub.put(Range.closedOpen(5, 5), 6); // should be a no-op assertEquals( ImmutableMap.of(Range.open(3, 7), 1, Range.closed(7, 9), 4, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); }
public void testSubRangeMapRemove() { 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)); assertEquals(ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges()); sub.remove(Range.closed(7, 9)); assertEquals( ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 7), 1, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); sub.remove(Range.closed(3, 9)); assertEquals( ImmutableMap.of(Range.openClosed(9, 10), 2), sub.asMapOfRanges()); assertEquals( ImmutableMap.of(Range.open(3, 5), 1, Range.openClosed(9, 10), 2, Range.closed(12, 16), 3), rangeMap.asMapOfRanges()); }