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); tokenMap = newTokenRing.build(); return servers; } catch (Exception e) {
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 (Map.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)); } } } } }
@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)); } } } } }
Opcode(List<VersionConstraint> versionConstraints, String opcodeName, int referenceType, int referenceType2, Format format, int flags) { ImmutableRangeMap.Builder<Integer, Short> apiToValueBuilder = ImmutableRangeMap.builder(); ImmutableRangeMap.Builder<Integer, Short> artVersionToValueBuilder = ImmutableRangeMap.builder(); for (VersionConstraint versionConstraint : versionConstraints) { if (!versionConstraint.apiRange.isEmpty()) { apiToValueBuilder.put(versionConstraint.apiRange, (short)versionConstraint.opcodeValue); } if (!versionConstraint.artVersionRange.isEmpty()) { artVersionToValueBuilder.put(versionConstraint.artVersionRange, (short)versionConstraint.opcodeValue); } } this.apiToValueMap = apiToValueBuilder.build(); this.artVersionToValueMap = artVersionToValueBuilder.build(); this.name = opcodeName; this.referenceType = referenceType; this.referenceType2 = referenceType2; this.format = format; this.flags = flags; }
Opcode(List<VersionConstraint> versionConstraints, String opcodeName, int referenceType, int referenceType2, Format format, int flags) { ImmutableRangeMap.Builder<Integer, Short> apiToValueBuilder = ImmutableRangeMap.builder(); ImmutableRangeMap.Builder<Integer, Short> artVersionToValueBuilder = ImmutableRangeMap.builder(); for (VersionConstraint versionConstraint : versionConstraints) { if (!versionConstraint.apiRange.isEmpty()) { apiToValueBuilder.put(versionConstraint.apiRange, (short)versionConstraint.opcodeValue); } if (!versionConstraint.artVersionRange.isEmpty()) { artVersionToValueBuilder.put(versionConstraint.artVersionRange, (short)versionConstraint.opcodeValue); } } this.apiToValueMap = apiToValueBuilder.build(); this.artVersionToValueMap = artVersionToValueBuilder.build(); this.name = opcodeName; this.referenceType = referenceType; this.referenceType2 = referenceType2; this.format = format; this.flags = flags; }
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 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); } } } }
@Builder public HashBasedShardResolver(int numBuckets) { int interval = MAX_BUCKET / numBuckets; int shardCounter = 0; boolean endReached = false; ImmutableRangeMap.Builder<String, String> builder = new ImmutableRangeMap.Builder<>(); for (int start = MIN_BUCKET; !endReached; start += interval, shardCounter++) { int end = start + interval - 1; endReached = !((MAX_BUCKET - start) > (2 * interval)); end = endReached ? end + MAX_BUCKET - end : end; builder.put(Range.closed(String.valueOf(start), String.valueOf(end)), String.valueOf(shardCounter)); } this.buckets = builder.build(); log.info("Buckets to shard allocation: {}", buckets); }
public void testBuilderRejectsEmptyRanges() { for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder(); try { builder.put(Range.closedOpen(i, i), 1); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { // success } try { builder.put(Range.openClosed(i, i), 1); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } } }
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); }
/** * Builds a mapping of block locations to file byte range */ private ImmutableRangeMap<Long,BlockLocation> buildBlockMap(FileStatus status) throws IOException { final Timer.Context context = metrics.timer(BLOCK_MAP_BUILDER_TIMER).time(); BlockLocation[] blocks; ImmutableRangeMap<Long,BlockLocation> blockMap; blocks = fs.getFileBlockLocations(status, 0 , status.getLen()); ImmutableRangeMap.Builder<Long, BlockLocation> blockMapBuilder = new ImmutableRangeMap.Builder<>(); for (BlockLocation block : blocks) { long start = block.getOffset(); long end = start + block.getLength(); Range<Long> range = Range.closedOpen(start, end); blockMapBuilder = blockMapBuilder.put(range, block); } blockMap = blockMapBuilder.build(); blockMapMap.put(status.getPath(), blockMap); context.stop(); return blockMap; }
private void createAttributeValueRangeMap() { double currentCount = 0, prevCount = 0; ImmutableRangeMap.Builder<Double, Integer> valuesWithProbabilityRangeBuilder = ImmutableRangeMap.builder(); if (attributeValueRangeMap != null) { valuesWithProbabilityRangeBuilder.putAll(attributeValueRangeMap); } //is this right? for (Integer attributeValBinNumber : histogramOfCountsForValues.keySet()) { prevCount = currentCount; currentCount += histogramOfCountsForValues.get(attributeValBinNumber).doubleValue(); Range<Double> range = Range.openClosed(prevCount / actualSamples, currentCount / actualSamples); //prevCount/actualSamples is the start of the interval we associate with this attribute value. valuesWithProbabilityRangeBuilder.put(range, attributeValBinNumber); } attributeValueRangeMap = valuesWithProbabilityRangeBuilder.build(); }
@GwtIncompatible static <T, K extends Comparable<? super K>, V> Collector<T, ?, ImmutableRangeMap<K, V>> toImmutableRangeMap( Function<? super T, Range<K>> keyFunction, Function<? super T, ? extends V> valueFunction) { checkNotNull(keyFunction); checkNotNull(valueFunction); return Collector.of( ImmutableRangeMap::<K, V>builder, (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)), ImmutableRangeMap.Builder::combine, ImmutableRangeMap.Builder::build); } }
@Test public void testBuildRangeMap() { BlockLocation[] blocks = buildBlockLocations(new String[4], 256*1024*1024); long tA = System.nanoTime(); ImmutableRangeMap.Builder<Long, BlockLocation> blockMapBuilder = new ImmutableRangeMap.Builder<>(); for (BlockLocation block : blocks) { long start = block.getOffset(); long end = start + block.getLength(); Range<Long> range = Range.closedOpen(start, end); blockMapBuilder = blockMapBuilder.put(range, block); } ImmutableRangeMap<Long,BlockLocation> map = blockMapBuilder.build(); long tB = System.nanoTime(); System.out.println(String.format("Took %f ms to build range map", (tB - tA) / 1e6)); }
@GwtIncompatible static <T, K extends Comparable<? super K>, V> Collector<T, ?, ImmutableRangeMap<K, V>> toImmutableRangeMap( Function<? super T, Range<K>> keyFunction, Function<? super T, ? extends V> valueFunction) { checkNotNull(keyFunction); checkNotNull(valueFunction); return Collector.of( ImmutableRangeMap::<K, V>builder, (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)), ImmutableRangeMap.Builder::combine, ImmutableRangeMap.Builder::build); } }
private void createAttributeValueRangeMap() { double currentCount = 0, prevCount = 0; ImmutableRangeMap.Builder<Double, Serializable> valuesWithProbabilityRangeBuilder = ImmutableRangeMap.builder(); // if (attributeValueRangeMap!=null) { // valuesWithProbabilityRangeBuilder.putAll(attributeValueRangeMap); // } for (Serializable attributeVal : histogramOfCountsForValues.keySet()) { prevCount = currentCount; currentCount += histogramOfCountsForValues.get(attributeVal).doubleValue(); Range<Double> range = Range.closedOpen(prevCount/actualSamples, currentCount/actualSamples); valuesWithProbabilityRangeBuilder.put(range, attributeVal); } attributeValueRangeMap = valuesWithProbabilityRangeBuilder.build(); }