static <T, K, V> Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap( Comparator<? super K> comparator, Function<? super T, ? extends K> keyFunction, Function<? super T, ? extends V> valueFunction) { checkNotNull(comparator); checkNotNull(keyFunction); checkNotNull(valueFunction); /* * We will always fail if there are duplicate keys, and the keys are always sorted by * the Comparator, so the entries can come in in arbitrary order -- so we report UNORDERED. */ return Collector.of( () -> new ImmutableSortedMap.Builder<K, V>(comparator), (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)), ImmutableSortedMap.Builder::combine, ImmutableSortedMap.Builder::build, Collector.Characteristics.UNORDERED); }
@Override public SortedMap<String, String> create(Entry<String, String>[] entries) { ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder(); for (Entry<String, String> entry : entries) { checkNotNull(entry); builder.put(entry.getKey(), entry.getValue()); } return builder.build(); } }
public static SortedMap<String, ConnectorId> listCatalogs(Session session, Metadata metadata, AccessControl accessControl) { Map<String, ConnectorId> catalogNames = metadata.getCatalogNames(session); Set<String> allowedCatalogs = accessControl.filterCatalogs(session.getIdentity(), catalogNames.keySet()); ImmutableSortedMap.Builder<String, ConnectorId> result = ImmutableSortedMap.naturalOrder(); for (Map.Entry<String, ConnectorId> entry : catalogNames.entrySet()) { if (allowedCatalogs.contains(entry.getKey())) { result.put(entry); } } return result.build(); }
@GwtIncompatible // NavigableMap public void testSubMap_unnaturalOrdering() { ImmutableSortedMap<Integer, Integer> map = ImmutableSortedMap.<Integer, Integer>reverseOrder() .put(2, 0) .put(4, 0) .put(6, 0) .put(8, 0) .put(10, 0) .build(); try { Maps.subMap(map, Range.closed(4, 8)); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException expected) { } // These results are all incorrect, but there's no way (short of iterating over the result) // to verify that with an arbitrary ordering or comparator. assertEquals(ImmutableSortedMap.of(2, 0, 4, 0), Maps.subMap(map, Range.atLeast(4))); assertEquals(ImmutableSortedMap.of(8, 0, 10, 0), Maps.subMap(map, Range.atMost(8))); assertEquals( ImmutableSortedMap.of(2, 0, 4, 0, 6, 0, 8, 0, 10, 0), Maps.subMap(map, Range.<Integer>all())); } }
public void testBuilder_withMutableEntry() { ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); final StringHolder holder = new StringHolder(); holder.string = "one"; Entry<String, Integer> entry = new AbstractMapEntry<String, Integer>() { @Override public String getKey() { return holder.string; } @Override public Integer getValue() { return 1; } }; builder.put(entry); holder.string = "two"; assertMapEquals(builder.build(), "one", 1); }
public void testToImmutableSortedMap() { Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = ImmutableSortedMap.toImmutableSortedMap( String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue); BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>> equivalence = Equivalence.equals() .onResultOf(ImmutableSortedMap<String, Integer>::comparator) .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList())) .and(Equivalence.equals()); ImmutableSortedMap<String, Integer> expected = ImmutableSortedMap.<String, Integer>orderedBy(String.CASE_INSENSITIVE_ORDER) .put("one", 1) .put("three", 3) .put("two", 2) .build(); CollectorTester.of(collector, equivalence) .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3)); }
public void testBuilder_withImmutableEntryAndNullContents() { Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); try { builder.put(Maps.immutableEntry("one", (Integer) null)); fail(); } catch (NullPointerException expected) { } try { builder.put(Maps.immutableEntry((String) null, 1)); fail(); } catch (NullPointerException expected) { } }
public void testBuilderComparator() { Comparator<String> comparator = Ordering.natural().reverse(); ImmutableSortedMap<String, Integer> map = new ImmutableSortedMap.Builder<String, Integer>(comparator) .put("one", 1) .put("two", 2) .put("three", 3) .put("four", 4) .put("five", 5) .build(); assertMapEquals(map, "two", 2, "three", 3, "one", 1, "four", 4, "five", 5); assertSame(comparator, map.comparator()); }
public void testBuilderReverseOrder() { ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.<String, Integer>reverseOrder() .put("one", 1) .put("two", 2) .put("three", 3) .put("four", 4) .put("five", 5) .build(); assertMapEquals(map, "two", 2, "three", 3, "one", 1, "four", 4, "five", 5); assertEquals(Ordering.natural().reverse(), map.comparator()); }
public void testSingletonBuilder() { ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.<String, Integer>naturalOrder().put("one", 1).build(); assertMapEquals(map, "one", 1); }
@Override public List<Entry<String, Integer>> create(Object... elements) { ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<String, Integer> entry = (Entry<String, Integer>) o; builder.put(entry); } return builder.build().entrySet().asList(); } }
@Override protected SortedMap<String, String> create(Entry<String, String>[] entries) { ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder(); for (Entry<String, String> entry : entries) { builder.put(entry.getKey(), entry.getValue()); } return new StandardImplForwardingSortedMap<>(builder.build()); } })
public void testBuilderPutNullKey() { Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); try { builder.put(null, 1); fail(); } catch (NullPointerException expected) { } }
public void testBuilder_withImmutableEntry() { ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.<String, Integer>naturalOrder() .put(Maps.immutableEntry("one", 1)) .build(); assertMapEquals(map, "one", 1); }
public void testBuilderPutNullValue() { Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); try { builder.put("one", null); fail(); } catch (NullPointerException expected) { } }
@Override protected List<String> create(String[] elements) { ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); for (int i = 0; i < elements.length; i++) { builder.put(elements[i], i); } return builder.build().keySet().asList(); }
@Override protected List<String> create(String[] elements) { ImmutableSortedMap.Builder<Integer, String> builder = ImmutableSortedMap.naturalOrder(); for (int i = 0; i < elements.length; i++) { builder.put(i, elements[i]); } return builder.build().values().asList(); } }
public void testBuilderReuse() { Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); ImmutableSortedMap<String, Integer> mapOne = builder.put("one", 1).put("two", 2).build(); ImmutableSortedMap<String, Integer> mapTwo = builder.put("three", 3).put("four", 4).build(); assertMapEquals(mapOne, "one", 1, "two", 2); assertMapEquals(mapTwo, "four", 4, "one", 1, "three", 3, "two", 2); }