How to use

builder

method

in

com.google.common.collect.ImmutableMap

 @Override
 protected Map<String, String> create(Entry<String, String>[] entries) {
  ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
  for (Entry<String, String> entry : entries) {
   builder.put(entry.getKey(), entry.getValue());
  }
  return builder.build();
 }
}

/** Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}. */
final TypeTable where(Map<TypeVariableKey, ? extends Type> mappings) {
 ImmutableMap.Builder<TypeVariableKey, Type> builder = ImmutableMap.builder();
 builder.putAll(map);
 for (Entry<TypeVariableKey, ? extends Type> mapping : mappings.entrySet()) {
  TypeVariableKey variable = mapping.getKey();
  Type type = mapping.getValue();
  checkArgument(!variable.equalsType(type), "Type variable %s bound to itself", variable);
  builder.put(variable, type);
 }
 return new TypeTable(builder.build());
}

private Map<Symbol, Integer> createJoinSourcesLayout(Map<Symbol, Integer> lookupSourceLayout, Map<Symbol, Integer> probeSourceLayout)
{
  Builder<Symbol, Integer> joinSourcesLayout = ImmutableMap.builder();
  joinSourcesLayout.putAll(lookupSourceLayout);
  for (Map.Entry<Symbol, Integer> probeLayoutEntry : probeSourceLayout.entrySet()) {
    joinSourcesLayout.put(probeLayoutEntry.getKey(), probeLayoutEntry.getValue() + lookupSourceLayout.size());
  }
  return joinSourcesLayout.build();
}

 @Override
 public Collection<UnhashableObject> create(UnhashableObject[] elements) {
  ImmutableMap.Builder<Integer, UnhashableObject> builder = ImmutableMap.builder();
  int key = 1;
  for (UnhashableObject value : elements) {
   builder.put(key++, value);
  }
  return builder.build().values();
 }
}

  @JsonProperty
  public synchronized Map<String, Double> getRecentFailuresByType()
  {
    ImmutableMap.Builder<String, Double> builder = ImmutableMap.builder();
    for (Map.Entry<Class<? extends Throwable>, DecayCounter> entry : failureCountByType.entrySet()) {
      builder.put(entry.getKey().getName(), entry.getValue().getCount());
    }
    return builder.build();
  }
}

 @Override
 public List<Entry<String, Integer>> create(Object... elements) {
  ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
  for (Object o : elements) {
   @SuppressWarnings("unchecked")
   Entry<String, Integer> entry = (Entry<String, Integer>) o;
   builder.put(entry);
  }
  return builder.build().entrySet().asList();
 }
}

public static Map<String, String> arrayValueToSimple(final Map<String, String[]> map) {
  ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
  for (Map.Entry<String, String[]> entry : map.entrySet()) {
    builder.put(entry.getKey(), entry.getValue()[0]);
  }
  return builder.build();
}

 @Override
 public List<String> create(String[] elements) {
  ImmutableMap.Builder<Integer, String> builder = ImmutableMap.builder();
  for (int i = 0; i < elements.length; i++) {
   builder.put(i, elements[i]);
  }
  return builder.build().values().asList();
 }
}

public static Map<String, String[]> simpleValueToArray(final Map<String, String> map) {
  ImmutableMap.Builder<String, String[]> builder = ImmutableMap.builder();
  for (Map.Entry<String, String> entry : map.entrySet()) {
    builder.put(entry.getKey(), new String[]{entry.getValue()});
  }
  return builder.build();
}

 @Override
 public List<String> create(String[] elements) {
  ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
  for (int i = 0; i < elements.length; i++) {
   builder.put(elements[i], i);
  }
  return builder.build().keySet().asList();
 }
}

public static Map<String, String[]> iterableValueToArray(final Map<String, Iterable<String>> map) {
  ImmutableMap.Builder<String, String[]> builder = ImmutableMap.builder();
  for (Map.Entry<String, Iterable<String>> entry : map.entrySet()) {
    Iterable<String> value = entry.getValue();
    builder.put(entry.getKey(), Iterables.toArray(value, String.class));
  }
  return builder.build();
}

@Override
public Map<String, Collection<Integer>> create(Object... elements) {
 ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
 // assumes that each set is a singleton or less (as is done for the samples)
 for (Object elem : elements) {
  @SuppressWarnings("unchecked") // safe by generator contract
  Entry<String, Collection<Integer>> entry = (Entry<String, Collection<Integer>>) elem;
  Integer value = Iterables.getOnlyElement(entry.getValue());
  builder.put(entry.getKey(), value);
 }
 return builder.build().asMultimap().asMap();
}

@Override
public Map<SchemaTableName, List<ColumnMetadata>> listTableColumns(ConnectorSession session, SchemaTablePrefix prefix)
{
  requireNonNull(prefix, "prefix is null");
  ImmutableMap.Builder<SchemaTableName, List<ColumnMetadata>> builder = ImmutableMap.builder();
  for (Entry<SchemaTableName, ConnectorTableMetadata> entry : TABLES.entrySet()) {
    if (prefix.matches(entry.getKey())) {
      builder.put(entry.getKey(), entry.getValue().getColumns());
    }
  }
  return builder.build();
}

/**
 * Parses a serialized trie representation of a map of reversed public suffixes into an immutable
 * map of public suffixes.
 */
static ImmutableMap<String, PublicSuffixType> parseTrie(CharSequence encoded) {
 ImmutableMap.Builder<String, PublicSuffixType> builder = ImmutableMap.builder();
 int encodedLen = encoded.length();
 int idx = 0;
 while (idx < encodedLen) {
  idx += doParseTrieToBuilder(Lists.<CharSequence>newLinkedList(), encoded, idx, builder);
 }
 return builder.build();
}

/**
 * Returns the output to input symbol mapping for the given source channel
 */
public Map<Symbol, SymbolReference> sourceSymbolMap(int sourceIndex)
{
  ImmutableMap.Builder<Symbol, SymbolReference> builder = ImmutableMap.builder();
  for (Map.Entry<Symbol, Collection<Symbol>> entry : outputToInputs.asMap().entrySet()) {
    builder.put(entry.getKey(), Iterables.get(entry.getValue(), sourceIndex).toSymbolReference());
  }
  return builder.build();
}

@Override
public Object getInfo()
{
  return ImmutableMap.builder()
      .put("hosts", addresses)
      .put("schema", schema)
      .put("table", table)
      .put("partitionId", partitionId)
      .build();
}

private ImmutableMap<String, Object> fetParamsMap(HttpServletRequest request) {
  final Map<String, String[]> parameterMap = request.getParameterMap();
  final ImmutableMap.Builder<String, Object> singleValueParams = ImmutableMap.builder();
  for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
    singleValueParams.put(entry.getKey(), entry.getValue()[0]);
  }
  return singleValueParams.build();
}

 private Map<String, Long> getCurrentValues()
 {
  final ImmutableMap.Builder<String, Long> builder = ImmutableMap.builder();
  for (Map.Entry<String, AtomicLong> entry : counters.entrySet()) {
   builder.put(entry.getKey(), entry.getValue().get());
  }
  for (Map.Entry<String, AtomicLong> entry : meters.entrySet()) {
   builder.put(entry.getKey(), entry.getValue().get());
  }
  return builder.build();
 }
};

public MemoryInfo getInfo()
{
  ImmutableMap.Builder<MemoryPoolId, MemoryPoolInfo> builder = ImmutableMap.builder();
  for (Map.Entry<MemoryPoolId, MemoryPool> entry : pools.entrySet()) {
    builder.put(entry.getKey(), entry.getValue().getInfo());
  }
  return new MemoryInfo(maxMemory, builder.build());
}

/**
 * Creates an {@code ImmutableMap<String, String>} from a {@code Properties} instance. Properties
 * normally derive from {@code Map<Object, Object>}, but they typically contain strings, which is
 * awkward. This method lets you get a plain-old-{@code Map} out of a {@code Properties}.
 *
 * @param properties a {@code Properties} object to be converted
 * @return an immutable map containing all the entries in {@code properties}
 * @throws ClassCastException if any key in {@code Properties} is not a {@code String}
 * @throws NullPointerException if any key or value in {@code Properties} is null
 */
@GwtIncompatible // java.util.Properties
public static ImmutableMap<String, String> fromProperties(Properties properties) {
 ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
 for (Enumeration<?> e = properties.propertyNames(); e.hasMoreElements(); ) {
  String key = (String) e.nextElement();
  builder.put(key, properties.getProperty(key));
 }
 return builder.build();
}