Object createRangeMap() { Builder<K, V> builder = new Builder<>(); for (Entry<Range<K>, V> entry : mapOfRanges.entrySet()) { builder.put(entry.getKey(), entry.getValue()); } return builder.build(); }
Object createRangeMap() { Builder<K, V> builder = new Builder<>(); for (Entry<Range<K>, V> entry : mapOfRanges.entrySet()) { builder.put(entry.getKey(), entry.getValue()); } return builder.build(); }
Object createRangeMap() { Builder<K, V> builder = new Builder<>(); for (Entry<Range<K>, V> entry : mapOfRanges.entrySet()) { builder.put(entry.getKey(), entry.getValue()); } return builder.build(); }
public TimestampPartitioningMap<T> copyInstallingNewValue( long lowerBoundForNewVersion, T newValue) { RangeAndValue<T> latestEntry = getLatestEntry(); validateProvidedTimestampBounds(lowerBoundForNewVersion, newValue, latestEntry); ImmutableRangeMap.Builder<Long, T> builder = ImmutableRangeMap.builder(); copyOldRangesFromPreviousMap(latestEntry, builder); addNewRanges(lowerBoundForNewVersion, newValue, latestEntry, builder); return ImmutableTimestampPartitioningMap.of(builder.build()); }
Object createRangeMap() { Builder<K, V> builder = new Builder<K, V>(); for (Entry<Range<K>, V> entry : mapOfRanges.entrySet()) { builder.put(entry.getKey(), entry.getValue()); } return builder.build(); }
tokenMap = newTokenRing.build(); return servers; } catch (Exception e) {
@Test public void throwsIfInitialMapHasGapsInRange() { assertThatThrownBy(() -> TimestampPartitioningMap.of( ImmutableRangeMap.<Long, Integer>builder() .put(Range.closed(1L, 6L), 1) .put(Range.atLeast(8L), 2) .build())) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("While the span covers all timestamps, some are missing."); }
public TimestampPartitioningMap<T> copyInstallingNewValue( long lowerBoundForNewVersion, T newValue) { RangeAndValue<T> latestEntry = getLatestEntry(); validateProvidedTimestampBounds(lowerBoundForNewVersion, newValue, latestEntry); ImmutableRangeMap.Builder<Long, T> builder = ImmutableRangeMap.builder(); copyOldRangesFromPreviousMap(latestEntry, builder); addNewRanges(lowerBoundForNewVersion, newValue, latestEntry, builder); return ImmutableTimestampPartitioningMap.of(builder.build()); }
@Value.Lazy RangeMap<Long, T> rangeMapView() { ImmutableRangeMap.Builder<Long, T> builder = new ImmutableRangeMap.Builder<>(); timestampMappings() .forEach(rangeAndValue -> builder.put(rangeAndValue.longRange(), rangeAndValue.value())); return builder.build(); }
positionTokenMap = tokenLocations.build();
@AndroidIncompatible // slow public void testAsMapOfRanges() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { ImmutableRangeMap<Integer, Integer> rangeMap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); ImmutableMap<Range<Integer>, Integer> expectedAsMap = ImmutableMap.of(range1, 1, range2, 2); ImmutableMap<Range<Integer>, Integer> asMap = rangeMap.asMapOfRanges(); ImmutableMap<Range<Integer>, Integer> descendingMap = rangeMap.asDescendingMapOfRanges(); assertEquals(expectedAsMap, asMap); assertEquals(expectedAsMap, descendingMap); SerializableTester.reserializeAndAssert(asMap); SerializableTester.reserializeAndAssert(descendingMap); assertEquals( ImmutableList.copyOf(asMap.entrySet()).reverse(), ImmutableList.copyOf(descendingMap.entrySet())); for (Range<Integer> query : RANGES) { assertEquals(expectedAsMap.get(query), asMap.get(query)); } } } } }
public void testSubRangeMap() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { for (Range<Integer> subRange : RANGES) { ImmutableRangeMap<Integer, Integer> rangeMap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); ImmutableRangeMap.Builder<Integer, Integer> expectedBuilder = ImmutableRangeMap.builder(); for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) { if (entry.getKey().isConnected(subRange) && !entry.getKey().intersection(subRange).isEmpty()) { expectedBuilder.put(entry.getKey().intersection(subRange), entry.getValue()); } } ImmutableRangeMap<Integer, Integer> expected = expectedBuilder.build(); assertEquals(expected, rangeMap.subRangeMap(subRange)); } } } } }
public void testGetEntry() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { ImmutableRangeMap<Integer, Integer> rangeMap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { Entry<Range<Integer>, Integer> expectedEntry = null; if (range1.contains(i)) { expectedEntry = Maps.immutableEntry(range1, 1); } else if (range2.contains(i)) { expectedEntry = Maps.immutableEntry(range2, 2); } assertEquals(expectedEntry, rangeMap.getEntry(i)); } } } } }
public void testGet() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { ImmutableRangeMap<Integer, Integer> rangeMap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { Integer expectedValue = null; if (range1.contains(i)) { expectedValue = 1; } else if (range2.contains(i)) { expectedValue = 2; } assertEquals(expectedValue, rangeMap.get(i)); } } } } }
public void testSerialization() { ImmutableRangeMap<Integer, Integer> emptyRangeMap = ImmutableRangeMap.of(); SerializableTester.reserializeAndAssert(emptyRangeMap); ImmutableRangeMap<Integer, Integer> nonEmptyRangeMap = new ImmutableRangeMap.Builder<Integer, Integer>() .put(Range.closed(2, 4), 5) .put(Range.open(6, 7), 3) .put(Range.closedOpen(8, 10), 4) .put(Range.openClosed(15, 17), 2) .build(); ImmutableMap<Range<Integer>, Integer> test = nonEmptyRangeMap.asMapOfRanges(); for (Range<Integer> range : test.keySet()) { SerializableTester.reserializeAndAssert(range); } SerializableTester.reserializeAndAssert(test.keySet()); SerializableTester.reserializeAndAssert(nonEmptyRangeMap); }
public void testOverlapRejection() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { boolean expectRejection = range1.isConnected(range2) && !range1.intersection(range2).isEmpty(); ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder(); builder.put(range1, 1).put(range2, 2); try { ImmutableRangeMap<Integer, Integer> unused = builder.build(); assertFalse(expectRejection); } catch (IllegalArgumentException e) { assertTrue(expectRejection); } } } }
public void testSpanTwoRanges() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { RangeMap<Integer, Integer> rangemap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); assertEquals(range1.span(range2), rangemap.span()); } } } }
public void testSpanSingleRange() { for (Range<Integer> range : RANGES) { RangeMap<Integer, Integer> rangemap = ImmutableRangeMap.<Integer, Integer>builder().put(range, 1).build(); assertEquals(range, rangemap.span()); } }
public void testGetLargeRangeMap() { ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder(); for (int i = 0; i < 100; i++) { builder.put(Range.closedOpen(i, i + 1), i); } ImmutableRangeMap<Integer, Integer> map = builder.build(); for (int i = 0; i < 100; i++) { assertEquals(Integer.valueOf(i), map.get(i)); } }
public void testToImmutableRangeSet() { Range<Integer> rangeOne = Range.closedOpen(1, 5); Range<Integer> rangeTwo = Range.openClosed(6, 7); ImmutableRangeMap<Integer, Integer> rangeMap = new ImmutableRangeMap.Builder<Integer, Integer>().put(rangeOne, 1).put(rangeTwo, 6).build(); CollectorTester.of( ImmutableRangeMap.<Range<Integer>, Integer, Integer>toImmutableRangeMap( k -> k, k -> k.lowerEndpoint())) .expectCollects(rangeMap, rangeOne, rangeTwo); } }