private <T> SetMultimap<T, T> createMapping(List<T> keys, List<T> values) { checkArgument(keys.size() == values.size(), "Inputs must have the same size"); ImmutableSetMultimap.Builder<T, T> builder = ImmutableSetMultimap.builder(); for (int i = 0; i < keys.size(); i++) { builder.put(keys.get(i), values.get(i)); } return builder.build(); }
@GwtIncompatible // SerializableTester public void testSortedSerialization() { Multimap<String, Integer> multimap = new ImmutableSetMultimap.Builder<String, Integer>() .orderKeysBy(Ordering.natural().reverse()) .orderValuesBy(Ordering.usingToString()) .put("a", 2) .put("a", 10) .put("b", 1) .build(); multimap = SerializableTester.reserialize(multimap); assertThat(multimap.keySet()).containsExactly("b", "a").inOrder(); assertThat(multimap.get("a")).containsExactly(10, 2).inOrder(); assertEquals( Ordering.usingToString(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator()); assertEquals( Ordering.usingToString(), ((ImmutableSortedSet<Integer>) multimap.get("z")).comparator()); }
public void testBuilder_withMutableEntry() { ImmutableSetMultimap.Builder<String, Integer> builder = new Builder<>(); 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"; assertEquals(ImmutableSet.of(1), builder.build().get("one")); }
for (LibraryModels libraryModels : models) { for (Map.Entry<MethodRef, Integer> entry : libraryModels.failIfNullParameters().entries()) { failIfNullParametersBuilder.put(entry); explicitlyNullableParametersBuilder.put(entry); nonNullParametersBuilder.put(entry); nullImpliesTrueParametersBuilder.put(entry); failIfNullParameters = failIfNullParametersBuilder.build(); explicitlyNullableParameters = explicitlyNullableParametersBuilder.build(); nonNullParameters = nonNullParametersBuilder.build(); nullImpliesTrueParameters = nullImpliesTrueParametersBuilder.build(); nullableReturns = nullableReturnsBuilder.build();
@Override public SetMultimap<String, Measure> getRawMeasures(Component component) { T componentKey = componentToKey.apply(component); Map<MeasureKey, Measure> rawMeasures = measures.get(componentKey); if (rawMeasures == null) { return ImmutableSetMultimap.of(); } ImmutableSetMultimap.Builder<String, Measure> builder = ImmutableSetMultimap.builder(); for (Map.Entry<MeasureKey, Measure> entry : rawMeasures.entrySet()) { builder.put(entry.getKey().getMetricKey(), entry.getValue()); } return builder.build(); }
/** * Given a list of actual elements and a list of expected elements, finds a many:many mapping * between actual and expected elements where a pair of elements maps if it satisfies the * correspondence. Returns this mapping as a multimap where the keys are indexes into the actual * list and the values are indexes into the expected list. Any exceptions are treated as if the * elements did not correspond, and the exception added to the store. */ private ImmutableSetMultimap<Integer, Integer> findCandidateMapping( List<? extends A> actual, List<? extends E> expected, Correspondence.ExceptionStore exceptions) { ImmutableSetMultimap.Builder<Integer, Integer> mapping = ImmutableSetMultimap.builder(); for (int actualIndex = 0; actualIndex < actual.size(); actualIndex++) { for (int expectedIndex = 0; expectedIndex < expected.size(); expectedIndex++) { if (correspondence.safeCompare( actual.get(actualIndex), expected.get(expectedIndex), exceptions)) { mapping.put(actualIndex, expectedIndex); } } } return mapping.build(); }
ImmutableMultimap<State, Service> servicesByState() { ImmutableSetMultimap.Builder<State, Service> builder = ImmutableSetMultimap.builder(); monitor.enter(); try { for (Entry<State, Service> entry : servicesByState.entries()) { if (!(entry.getValue() instanceof NoOpService)) { builder.put(entry); } } } finally { monitor.leave(); } return builder.build(); }
/** * {@inheritDoc} */ @Override public Multimap<String, NotificationChannel> findSubscribedRecipientsForDispatcher(NotificationDispatcher dispatcher, String projectKey, SubscriberPermissionsOnProject subscriberPermissionsOnProject) { requireNonNull(projectKey, "projectKey is mandatory"); String dispatcherKey = dispatcher.getKey(); Set<SubscriberAndChannel> subscriberAndChannels = Arrays.stream(notificationChannels) .flatMap(notificationChannel -> toSubscriberAndChannels(dispatcherKey, projectKey, notificationChannel)) .collect(Collectors.toSet()); if (subscriberAndChannels.isEmpty()) { return ImmutableMultimap.of(); } ImmutableSetMultimap.Builder<String, NotificationChannel> builder = ImmutableSetMultimap.builder(); try (DbSession dbSession = dbClient.openSession(false)) { Set<String> authorizedLogins = keepAuthorizedLogins(dbSession, projectKey, subscriberAndChannels, subscriberPermissionsOnProject); subscriberAndChannels.stream() .filter(subscriberAndChannel -> authorizedLogins.contains(subscriberAndChannel.getSubscriber().getLogin())) .forEach(subscriberAndChannel -> builder.put(subscriberAndChannel.getSubscriber().getLogin(), subscriberAndChannel.getChannel())); } return builder.build(); }
ImmutableSet.Builder<Node> shuttingDownNodesBuilder = ImmutableSet.builder(); ImmutableSet.Builder<Node> coordinatorsBuilder = ImmutableSet.builder(); ImmutableSetMultimap.Builder<ConnectorId, Node> byConnectorIdBuilder = ImmutableSetMultimap.builder(); connectorIds = connectorIds.toLowerCase(ENGLISH); for (String connectorId : CONNECTOR_ID_SPLITTER.split(connectorIds)) { byConnectorIdBuilder.put(new ConnectorId(connectorId), node); byConnectorIdBuilder.put(new ConnectorId(GlobalSystemConnector.NAME), node); break; case INACTIVE: activeNodesByConnectorId = byConnectorIdBuilder.build(); coordinators = coordinatorsBuilder.build();
/** * Returns an immutable multimap containing the given entries, in order. Repeated occurrences of * an entry (according to {@link Object#equals}) after the first are ignored. */ public static <K, V> ImmutableSetMultimap<K, V> of(K k1, V v1, K k2, V v2) { ImmutableSetMultimap.Builder<K, V> builder = ImmutableSetMultimap.builder(); builder.put(k1, v1); builder.put(k2, v2); return builder.build(); }
throws InvalidCheckpointException ImmutableSetMultimap.Builder<Integer, StreamKind> streamKindsBuilder = ImmutableSetMultimap.builder(); for (Stream stream : streams.values()) { streamKindsBuilder.put(stream.getColumn(), stream.getStreamKind()); SetMultimap<Integer, StreamKind> streamKinds = streamKindsBuilder.build();
/** * Returns an immutable multimap containing the given entries, in order. Repeated occurrences of * an entry (according to {@link Object#equals}) after the first are ignored. */ public static <K, V> ImmutableSetMultimap<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) { ImmutableSetMultimap.Builder<K, V> builder = ImmutableSetMultimap.builder(); builder.put(k1, v1); builder.put(k2, v2); builder.put(k3, v3); return builder.build(); }
/** * Return measures that were added by the step (using {@link #add(Component, Metric, Measure)}). * It does not contain the one added in the test by {@link #addRawMeasure(int, String, Measure)} */ public SetMultimap<String, Measure> getAddedRawMeasures(Component component) { checkAndInitProvidersState(); ImmutableSetMultimap.Builder<String, Measure> builder = ImmutableSetMultimap.builder(); for (Map.Entry<InternalKey, Measure> entry : from(filterKeys(rawMeasures, hasComponentRef(component)).entrySet()).filter(isAddedMeasure)) { builder.put(entry.getKey().getMetricKey(), entry.getValue()); } return builder.build(); }
ImmutableMultimap<State, Service> servicesByState() { ImmutableSetMultimap.Builder<State, Service> builder = ImmutableSetMultimap.builder(); monitor.enter(); try { for (Entry<State, Service> entry : servicesByState.entries()) { if (!(entry.getValue() instanceof NoOpService)) { builder.put(entry); } } } finally { monitor.leave(); } return builder.build(); }