@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(); }
public void testBuilderPutAll() { Map<String, Integer> toPut = new LinkedHashMap<>(); toPut.put("one", 1); toPut.put("two", 2); toPut.put("three", 3); Map<String, Integer> moreToPut = new LinkedHashMap<>(); moreToPut.put("four", 4); moreToPut.put("five", 5); ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.<String, Integer>naturalOrder() .putAll(toPut) .putAll(moreToPut) .build(); assertMapEquals(map, "five", 5, "four", 4, "one", 1, "three", 3, "two", 2); }
@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 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); }
public void testEmptyBuilder() { ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.<String, Integer>naturalOrder().build(); assertEquals(Collections.<String, Integer>emptyMap(), map); }
@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 testBuilderPutAllWithEmptyMap() { ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.<String, Integer>naturalOrder() .putAll(Collections.<String, Integer>emptyMap()) .build(); assertEquals(Collections.<String, Integer>emptyMap(), map); }
@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(); }
static ImmutableSortedMap<Object, Object> instantiate(SerializationStreamReader reader) throws SerializationException { /* * Nothing we can do, but we're already assuming the serialized form is * correctly typed, anyway. */ @SuppressWarnings("unchecked") Comparator<Object> comparator = (Comparator<Object>) reader.readObject(); SortedMap<Object, Object> entries = new TreeMap<>(comparator); Map_CustomFieldSerializerBase.deserialize(reader, entries); return ImmutableSortedMap.orderedBy(comparator).putAll(entries).build(); }
public void testPuttingTheSameKeyTwiceThrowsOnBuild() { Builder<String, Integer> builder = ImmutableSortedMap.<String, Integer>naturalOrder() .put("one", 1) .put("one", 2); // throwing on this line would be even better try { builder.build(); fail(); } catch (IllegalArgumentException 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 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); }
public void testBuilder() { ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.<String, Integer>naturalOrder() .put("one", 1) .put("two", 2) .put("three", 3) .put("four", 4) .put("five", 5) .build(); assertMapEquals(map, "five", 5, "four", 4, "one", 1, "three", 3, "two", 2); }
@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(); } }