public void publishSegments(Iterable<DataSegment> segments) throws IOException { // Request segment pushes for each set final Multimap<Interval, DataSegment> segmentMultimap = Multimaps.index( segments, new Function<DataSegment, Interval>() { @Override public Interval apply(DataSegment segment) { return segment.getInterval(); } } ); for (final Collection<DataSegment> segmentCollection : segmentMultimap.asMap().values()) { getTaskActionClient().submit(new SegmentInsertAction(ImmutableSet.copyOf(segmentCollection))); } }
@Override protected Iterator<Integer> newTargetIterator() { Map<String, Integer> map = Maps.newHashMap(); map.put("foo", 1); map.put("bar", 2); multimap = Multimaps.forMap(map); return multimap.get("foo").iterator(); }
@GwtIncompatible(value = "untested") public void testTransformValuesIsView() { Multimap<String, String> multimap = LinkedListMultimap.create(); multimap.put("a", "a"); Multimap<String, Integer> transformed = Multimaps.transformValues( multimap, new Function<String, Integer>() { @Override public Integer apply(String str) { return str.length(); } }); Entry<String, String> entry = multimap.entries().iterator().next(); entry.setValue("bbb"); assertThat(transformed.entries()).containsExactly(immutableEntry("a", 3)); }
Multimap<K, V> unfiltered, final Predicate<? super K> keyPredicate) { if (unfiltered instanceof SetMultimap) { return filterKeys((SetMultimap<K, V>) unfiltered, keyPredicate); } else if (unfiltered instanceof ListMultimap) { return filterKeys((ListMultimap<K, V>) unfiltered, keyPredicate); } else if (unfiltered instanceof FilteredKeyMultimap) { FilteredKeyMultimap<K, V> prev = (FilteredKeyMultimap<K, V>) unfiltered; return new FilteredKeyMultimap<>( prev.unfiltered, Predicates.<K>and(prev.keyPredicate, keyPredicate)); } else if (unfiltered instanceof FilteredMultimap) { FilteredMultimap<K, V> prev = (FilteredMultimap<K, V>) unfiltered; return filterFiltered(prev, Maps.<K>keyPredicateOnEntries(keyPredicate)); } else { return new FilteredKeyMultimap<>(unfiltered, keyPredicate);
public void testAsMap_multimap() { Multimap<String, Integer> multimap = Multimaps.newMultimap(new HashMap<String, Collection<Integer>>(), new QueueSupplier()); Map<String, Collection<Integer>> map = Multimaps.asMap(multimap); assertSame(multimap.asMap(), map); }
public void testFilterFiltered() { Multimap<String, Integer> unfiltered = HashMultimap.create(); unfiltered.put("foo", 55556); unfiltered.put("badkey", 1); unfiltered.put("foo", 1); Multimap<String, Integer> keyFiltered = Multimaps.filterKeys(unfiltered, KEY_PREDICATE); Multimap<String, Integer> filtered = Multimaps.filterValues(keyFiltered, VALUE_PREDICATE); assertEquals(1, filtered.size()); assertTrue(filtered.containsEntry("foo", 1)); assertTrue(filtered.keySet().retainAll(Arrays.asList("cat", "dog"))); assertEquals(0, filtered.size()); }
public void testForMap() { Map<String, Integer> map = Maps.newHashMap(); map.put("foo", 1); map.put("bar", 2); Multimap<String, Integer> multimap = HashMultimap.create(); multimap.put("foo", 1); multimap.put("bar", 2); Multimap<String, Integer> multimapView = Multimaps.forMap(map); new EqualsTester().addEqualityGroup(multimap, multimapView).addEqualityGroup(map).testEquals(); Multimap<String, Integer> multimap2 = HashMultimap.create(); multimap2.put("foo", 1); assertFalse(multimapView.equals(multimap2)); multimap2.put("bar", 1); assertThat(multimapView.keys()).contains("foo"); assertThat(multimapView.values()).contains(1); assertThat(multimapView.entries()).contains(Maps.immutableEntry("foo", 1)); assertThat(multimapView.asMap().entrySet()) .contains(Maps.immutableEntry("foo", (Collection<Integer>) Collections.singleton(1))); multimapView.clear(); assertFalse(multimapView.containsKey("foo"));
void awaitHealthy(long timeout, TimeUnit unit) throws TimeoutException { monitor.enter(); try { if (!monitor.waitForUninterruptibly(awaitHealthGuard, timeout, unit)) { throw new TimeoutException( "Timeout waiting for the services to become healthy. The " + "following services have not started: " + Multimaps.filterKeys(servicesByState, in(ImmutableSet.of(NEW, STARTING)))); } checkHealthy(); } finally { monitor.leave(); } }
@Override ListMultimap<String, Integer> filter(ListMultimap<String, Integer> multimap) { multimap.put("foo", 17); multimap.put("bar", 32); multimap.put("foo", 16); return Multimaps.filterKeys( multimap, Predicates.not(Predicates.in(ImmutableSet.of("foo", "bar")))); } })
@Override public Set<? extends NodeMetadata> listNodesByIds(Iterable<String> ids) { Multimap<String, String> idsByHandles = index(ids, splitHandle(1)); Multimap<String, String> idsByRegions = transformValues(idsByHandles, splitHandle(0)); Multimap<String, String> idsByConfiguredRegions = filterKeys(idsByRegions, in(regions.get())); if (idsByConfiguredRegions.isEmpty()) { return ImmutableSet.of(); } Iterable<? extends RunningInstance> instances = pollRunningInstancesByRegionsAndIds(idsByConfiguredRegions); Iterable<? extends NodeMetadata> nodes = transform(filter(instances, notNull()), runningInstanceToNodeMetadata); return ImmutableSet.copyOf(nodes); }
public void testForMapRemoveAll() { Map<String, Integer> map = Maps.newHashMap(); map.put("foo", 1); map.put("bar", 2); map.put("cow", 3); Multimap<String, Integer> multimap = Multimaps.forMap(map); assertEquals(3, multimap.size()); assertEquals(Collections.emptySet(), multimap.removeAll("dog")); assertEquals(3, multimap.size()); assertTrue(multimap.containsKey("bar")); assertEquals(Collections.singleton(2), multimap.removeAll("bar")); assertEquals(2, multimap.size()); assertFalse(multimap.containsKey("bar")); }
@Override protected Map<String, Collection<Integer>> makeEmptyMap() { Map<String, Integer> map = Maps.newHashMap(); return Multimaps.forMap(map).asMap(); }
/** * Returns the toString() description of every change in the changeset, sorted by type, * except for changes that implement {@link SummarizeAsGroup}, which will instead be counted. */ public Iterable<String> getChangeDescriptionsOrSummaries() { Iterable<String> uniqueDescriptions = ImmutableSet.copyOf(transform(filter(changes, not(summarizable)), toStringFunction())); Multimap<String, ProjectChange> summaries = Multimaps.index(changes, summarizableGroupName); return concat(Ordering.<String>natural().sortedCopy(uniqueDescriptions), filter(transform(summaries.asMap().entrySet(), summaryDescription), Predicates.notNull())); }
public void testForMapAsMap() { Map<String, Integer> map = Maps.newHashMap(); map.put("foo", 1); map.put("bar", 2); Map<String, Collection<Integer>> asMap = Multimaps.forMap(map).asMap(); assertEquals(Collections.singleton(1), asMap.get("foo")); assertNull(asMap.get("cow")); assertTrue(asMap.containsKey("foo")); assertFalse(asMap.containsKey("cow")); Set<Entry<String, Collection<Integer>>> entries = asMap.entrySet(); assertFalse(entries.contains((Object) 4.5)); assertFalse(entries.remove((Object) 4.5)); assertFalse(entries.contains(Maps.immutableEntry("foo", Collections.singletonList(1)))); assertFalse(entries.remove(Maps.immutableEntry("foo", Collections.singletonList(1)))); assertFalse(entries.contains(Maps.immutableEntry("foo", Sets.newLinkedHashSet(asList(1, 2))))); assertFalse(entries.remove(Maps.immutableEntry("foo", Sets.newLinkedHashSet(asList(1, 2))))); assertFalse(entries.contains(Maps.immutableEntry("foo", Collections.singleton(2)))); assertFalse(entries.remove(Maps.immutableEntry("foo", Collections.singleton(2)))); assertTrue(map.containsKey("foo")); assertTrue(entries.contains(Maps.immutableEntry("foo", Collections.singleton(1)))); assertTrue(entries.remove(Maps.immutableEntry("foo", Collections.singleton(1)))); assertFalse(map.containsKey("foo")); }
public void testNewMultimap() { // The ubiquitous EnumArrayBlockingQueueMultimap CountingSupplier<Queue<Integer>> factory = new QueueSupplier(); Map<Color, Collection<Integer>> map = Maps.newEnumMap(Color.class); Multimap<Color, Integer> multimap = Multimaps.newMultimap(map, factory); assertEquals(0, factory.count); multimap.putAll(Color.BLUE, asList(3, 1, 4)); assertEquals(1, factory.count); multimap.putAll(Color.RED, asList(2, 7, 1, 8)); assertEquals(2, factory.count); assertEquals("[3, 1, 4]", multimap.get(Color.BLUE).toString()); Multimap<Color, Integer> ummodifiable = Multimaps.unmodifiableMultimap(multimap); assertEquals("[3, 1, 4]", ummodifiable.get(Color.BLUE).toString()); Collection<Integer> collection = multimap.get(Color.BLUE); assertEquals(collection, collection); assertFalse(multimap.keySet() instanceof SortedSet); assertFalse(multimap.asMap() instanceof SortedMap); }
/** * Construct an HttpResponse from a builder (called by HttpResponseBuilder.create). */ HttpResponse(HttpResponseBuilder builder) { httpStatusCode = builder.getHttpStatusCode(); Multimap<String, String> headerCopy = HttpResponse.newHeaderMultimap(); // Always safe, HttpResponseBuilder won't modify the body. responseBytes = builder.getResponse(); // Copy headers after builder.getResponse(), since that can modify Content-Type. headerCopy.putAll(builder.getHeaders()); Map<String, String> metadataCopy = Maps.newHashMap(builder.getMetadata()); metadata = Collections.unmodifiableMap(metadataCopy); // We want to modify the headers to ensure that the proper Content-Type and Date headers // have been set. This allows us to avoid these expensive calculations from the cache. date = getAndUpdateDate(headerCopy); encoding = getAndUpdateEncoding(headerCopy, responseBytes); headers = Multimaps.unmodifiableMultimap(headerCopy); }
!moduleDependenciesMap.containsKey(moduleName), "Module named '%s' was passed in multiple times.", moduleName); moduleDependenciesMap.putAll(moduleName, manifest.getUsesSplits()); if (moduleDependenciesMap.containsEntry(moduleName, BASE_MODULE_NAME)) { throw ValidationException.builder() .withMessage( return Multimaps.unmodifiableMultimap(moduleDependenciesMap);
@Nullable String nullKey, @Nullable Integer nullValue) { multimap.clear(); multimap.put("foo", 1); multimap.put("foo", 2); multimap.put("foo", 3); multimap.put("bar", 5); if (multimap instanceof SortedSetMultimap) { unmodifiable = Multimaps.unmodifiableSortedSetMultimap((SortedSetMultimap<String, Integer>) multimap); } else if (multimap instanceof SetMultimap) { unmodifiable = Multimaps.unmodifiableSetMultimap((SetMultimap<String, Integer>) multimap); } else if (multimap instanceof ListMultimap) { unmodifiable = Multimaps.unmodifiableListMultimap((ListMultimap<String, Integer>) multimap); } else { unmodifiable = Multimaps.unmodifiableMultimap(multimap);
public void testFilterKeys() { Multimap<String, Integer> unfiltered = HashMultimap.create(); unfiltered.put("foo", 55556); unfiltered.put("badkey", 1); Multimap<String, Integer> filtered = Multimaps.filterKeys(unfiltered, KEY_PREDICATE); assertEquals(1, filtered.size()); assertTrue(filtered.containsEntry("foo", 55556)); }
static ImmutableSet<Element> getElementsFromAnnotations( final SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation, Set<Class<? extends Annotation>> annotations) { return ImmutableSet.copyOf( Multimaps.filterKeys(elementsByAnnotation, Predicates.in(annotations)).values()); }