Java Code Examples for com.google.common.collect.Multimaps#transformValues()

private String computeToString() {
  StringBuilder builder = new StringBuilder().append(type).append('/').append(subtype);
  if (!parameters.isEmpty()) {
    builder.append("; ");
    Multimap<String, String> quotedParameters =
        Multimaps.transformValues(
            parameters,
            new Function<String, String>() {
              @Override
              public String apply(String value) {
                return TOKEN_MATCHER.matchesAllOf(value) ? value : escapeAndQuote(value);
              }
            });
    PARAMETER_JOINER.appendTo(builder, quotedParameters.entries());
  }
  return builder.toString();
}
 

static void validateNoDuplicateContacts(Set<DesignatedContact> contacts)
    throws ParameterValuePolicyErrorException {
  ImmutableMultimap<Type, Key<ContactResource>> contactsByType =
      contacts.stream()
          .collect(
              toImmutableSetMultimap(
                  DesignatedContact::getType, contact -> contact.getContactKey().getOfyKey()));

  // If any contact type has multiple contacts:
  if (contactsByType.asMap().values().stream().anyMatch(v -> v.size() > 1)) {
    // Find the duplicates.
    Map<Type, Collection<Key<ContactResource>>> dupeKeysMap =
        Maps.filterEntries(contactsByType.asMap(), e -> e.getValue().size() > 1);
    ImmutableList<Key<ContactResource>> dupeKeys =
        dupeKeysMap.values().stream().flatMap(Collection::stream).collect(toImmutableList());
    // Load the duplicates in one batch.
    Map<Key<ContactResource>, ContactResource> dupeContacts = ofy().load().keys(dupeKeys);
    ImmutableMultimap.Builder<Type, Key<ContactResource>> typesMap =
        new ImmutableMultimap.Builder<>();
    dupeKeysMap.forEach(typesMap::putAll);
    // Create an error message showing the type and contact IDs of the duplicates.
    throw new DuplicateContactForRoleException(
        Multimaps.transformValues(typesMap.build(), key -> dupeContacts.get(key).getContactId()));
  }
}
 

@PostConstruct
public void init(){
    aggregateForeignKeyReferences();

    refPaths =
    Multimaps.transformValues(refNodeLists, new Function<List<SchemaReferenceNode>, SchemaReferencePath>() {
        @Override
        public SchemaReferencePath apply(@Nullable List<SchemaReferenceNode> schemaReferenceNodes) {
            SchemaReferencePath path = new SchemaReferencePath(schemaReferenceNodes);
            String fullPath = path.getPath();
            String mappedPath = fieldMapping.get(fullPath);
            if(mappedPath != null) {
                path.setMappedPath(mappedPath);
            }
            return path;
        }
    });
}
 

/**
 * Returns the input to output symbol mapping for the given source channel.
 * A single input symbol can map to multiple output symbols, thus requiring a Multimap.
 */
public Multimap<Symbol, SymbolReference> outputSymbolMap(int sourceIndex)
{
    return Multimaps.transformValues(FluentIterable.from(getOutputSymbols())
            .toMap(outputToSourceSymbolFunction(sourceIndex))
            .asMultimap()
            .inverse(), Symbol::toSymbolReference);
}
 

private String computeToString() {
  StringBuilder builder = new StringBuilder().append(type).append('/').append(subtype);
  if (!parameters.isEmpty()) {
    builder.append("; ");
    Multimap<String, String> quotedParameters = Multimaps.transformValues(parameters, new Function<String, String>() {
                                                                                        @Override
                                                                                        public String apply(String value) {
                                                                                          return TOKEN_MATCHER.matchesAllOf(value) ? value : escapeAndQuote(value);
                                                                                        }
                                                                                      });
    PARAMETER_JOINER.appendTo(builder, quotedParameters.entries());
  }
  return builder.toString();
}
 

private String computeToString() {
  StringBuilder builder = new StringBuilder().append(type).append('/').append(subtype);
  if (!parameters.isEmpty()) {
    builder.append("; ");
    Multimap<String, String> quotedParameters = Multimaps.transformValues(parameters, new Function<String, String>() {
                                                                                        @Override
                                                                                        public String apply(String value) {
                                                                                          return TOKEN_MATCHER.matchesAllOf(value) ? value : escapeAndQuote(value);
                                                                                        }
                                                                                      });
    PARAMETER_JOINER.appendTo(builder, quotedParameters.entries());
  }
  return builder.toString();
}
 

private String computeToString() {
  StringBuilder builder = new StringBuilder().append(type).append('/').append(subtype);
  if (!parameters.isEmpty()) {
    builder.append("; ");
    Multimap<String, String> quotedParameters = Multimaps.transformValues(parameters, new Function<String, String>() {
                                                                                        @Override
                                                                                        public String apply(String value) {
                                                                                          return TOKEN_MATCHER.matchesAllOf(value) ? value : escapeAndQuote(value);
                                                                                        }
                                                                                      });
    PARAMETER_JOINER.appendTo(builder, quotedParameters.entries());
  }
  return builder.toString();
}
 

private String computeToString() {
  StringBuilder builder = new StringBuilder().append(type).append('/').append(subtype);
  if (!parameters.isEmpty()) {
    builder.append("; ");
    Multimap<String, String> quotedParameters = Multimaps.transformValues(parameters, new Function<String, String>() {
                                                                                        @Override
                                                                                        public String apply(String value) {
                                                                                          return TOKEN_MATCHER.matchesAllOf(value) ? value : escapeAndQuote(value);
                                                                                        }
                                                                                      });
    PARAMETER_JOINER.appendTo(builder, quotedParameters.entries());
  }
  return builder.toString();
}
 

private String computeToString() {
    StringBuilder builder = new StringBuilder().append(type).append('/').append(subtype);
    if (!parameters.isEmpty()) {
        builder.append("; ");
        Multimap<String, String> quotedParameters =
                Multimaps.transformValues(
                        parameters,
                        value -> TOKEN_MATCHER.matchesAllOf(value) ? value : escapeAndQuote(value));
        PARAMETER_JOINER.appendTo(builder, quotedParameters.entries());
    }
    return builder.toString();
}
 

private Multimap<String, String> getTasksByHosts(StoreProvider provider, Iterable<String> hosts) {
  if (Iterables.isEmpty(hosts)) {
    return ImmutableMultimap.of();
  }

  ImmutableSet.Builder<IScheduledTask> drainingTasks = ImmutableSet.builder();
  drainingTasks.addAll(provider.getTaskStore()
      .fetchTasks(Query.slaveScoped(hosts).byStatus(Tasks.SLAVE_ASSIGNED_STATES)));
  return Multimaps.transformValues(
      Multimaps.index(drainingTasks.build(), Tasks::scheduledToSlaveHost),
      Tasks::id);
}
 

private void assertStateUpdate(
    IJobUpdateKey key,
    JobUpdateStatus expected,
    Multimap<Integer, JobUpdateAction> expectedActions) {

  IJobUpdateDetails details = getDetails(key);
  Iterable<IJobInstanceUpdateEvent> orderedEvents =
      EVENT_ORDER.sortedCopy(details.getInstanceEvents());
  Multimap<Integer, IJobInstanceUpdateEvent> eventsByInstance =
      Multimaps.index(orderedEvents, EVENT_TO_INSTANCE);
  Multimap<Integer, JobUpdateAction> actionsByInstance =
      Multimaps.transformValues(eventsByInstance, JobUpdateControllerImpl.EVENT_TO_ACTION);
  assertEquals(expectedActions, actionsByInstance);
  assertEquals(expected, details.getUpdate().getSummary().getState().getStatus());
}
 

/**
 * Prints target and result map's json representation into printStream.
 *
 * @param targetsAndResults input to query result multi map
 * @param printStream print stream for output
 * @throws IOException in case of IO exception during json writing operation
 */
public static void printJsonOutput(
    Multimap<String, QueryTarget> targetsAndResults, PrintStream printStream) throws IOException {
  Multimap<String, String> targetsAndResultsNames =
      Multimaps.transformValues(
          targetsAndResults, input -> stringify(Objects.requireNonNull(input)));
  ObjectMappers.WRITER.writeValue(printStream, targetsAndResultsNames.asMap());
}
 

/**
 * Returns an immutable map from attribute name to list of configured targets for that attribute.
 */
public ListMultimap<String, ? extends TransitiveInfoCollection> getConfiguredTargetMap() {
  return Multimaps.transformValues(targetMap, ConfiguredTargetAndData::getConfiguredTarget);
}
 

private Multimap<String, PreemptionVictim> getVictims(IScheduledTask... tasks) {
  return Multimaps.transformValues(
      Multimaps.index(Arrays.asList(tasks), task -> task.getAssignedTask().getSlaveId()),
      task -> PreemptionVictim.fromTask(task.getAssignedTask())
  );
}