import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
public void testSortedMapTransformEntries() {
  SortedMap<String, String> map =
      sortedNotNavigable(ImmutableSortedMap.of("a", "4", "b", "9"));
  EntryTransformer<String, String, String> concat =
      new EntryTransformer<String, String, String>() {
        @Override
        public String transformEntry(String key, String value) {
          return key + value;
        }
      };
  SortedMap<String, String> transformed = transformEntries(map, concat);

  /*
   * We'd like to sanity check that we didn't get a NavigableMap out, but we
   * can't easily do so while maintaining GWT compatibility.
   */
  assertEquals(ImmutableSortedMap.of("a", "a4", "b", "b9"), transformed);
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@Override
public <ID> int updateFields(String tableName, ID id, Map<String, Object> valueMap) {
	StringBuilder sqlSb = new StringBuilder();
	sqlSb.append("UPDATE `");
	sqlSb.append(tableName);
	sqlSb.append("`  SET ");
	EntryTransformer<String, Object, String> transformer = new EntryTransformer<String, Object, String>() {
		@Override
		public String transformEntry(String key, Object value) {
			String column = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, key);
			return "`" + column + "`='" + value + "'";
		}
	};
	Map<String, String> transformed = Maps.transformEntries(valueMap, transformer);
	sqlSb.append(Joiner.on(",").join(transformed.values()));
	sqlSb.append(" WHERE `id`='" + id + "';");
	return jdbcTemplate.update(sqlSb.toString());
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
TransformedEntries(
    final EntryTransformer<? super K, ? super V1, V2> transformer) {
  super(fromMultimap.entries(),
      new Function<Entry<K, V1>, Entry<K, V2>>() {
        @Override public Entry<K, V2> apply(final Entry<K, V1> entry) {
          return new AbstractMapEntry<K, V2>() {

            @Override public K getKey() {
              return entry.getKey();
            }

            @Override public V2 getValue() {
              return transformer.transformEntry(
                  entry.getKey(), entry.getValue());
            }
          };
        }
      });
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@GwtIncompatible("NavigableMap")
public void testTransformEntriesSecretlyNavigable() {
  Map<String, String> map = ImmutableSortedMap.of("a", "4", "b", "9");
  EntryTransformer<String, String, String> concat =
      new EntryTransformer<String, String, String>() {
        @Override
        public String transformEntry(String key, String value) {
          return key + value;
        }
      };
  Map<String, String> transformed;

  transformed = transformEntries(map, concat);
  assertEquals(ImmutableMap.of("a", "a4", "b", "b9"), transformed);
  assertTrue(transformed instanceof NavigableMap);

  transformed = transformEntries((SortedMap<String, String>) map, concat);
  assertEquals(ImmutableMap.of("a", "a4", "b", "b9"), transformed);
  assertTrue(transformed instanceof NavigableMap);
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
Map<K, Collection<V>> createAsMap() {
  // Select the values that satisify the predicate.
  EntryTransformer<K, Collection<V>, Collection<V>> transformer
      = new EntryTransformer<K, Collection<V>, Collection<V>>() {
        @Override public Collection<V> transformEntry(K key, Collection<V> collection) {
          return filterCollection(collection, new ValuePredicate(key));
        }
  };
  Map<K, Collection<V>> transformed
      = Maps.transformEntries(unfiltered.asMap(), transformer);

  // Select the keys that have at least one value remaining.
  Map<K, Collection<V>> filtered = Maps.filterValues(transformed, NOT_EMPTY);

  // Override the removal methods, since removing a map entry should not
  // affect values that don't satisfy the filter.
  return new AsMap(filtered);
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
public void testSortedMapTransformEntries() {
  SortedMap<String, String> map = sortedNotNavigable(ImmutableSortedMap.of("a", "4", "b", "9"));
  EntryTransformer<String, String, String> concat =
      new EntryTransformer<String, String, String>() {
        @Override
        public String transformEntry(String key, String value) {
          return key + value;
        }
      };
  SortedMap<String, String> transformed = transformEntries(map, concat);

  /*
   * We'd like to sanity check that we didn't get a NavigableMap out, but we
   * can't easily do so while maintaining GWT compatibility.
   */
  assertEquals(ImmutableSortedMap.of("a", "a4", "b", "b9"), transformed);
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
/**
 * Creates a new vocabulary backed by the given {@link Enum} class and with
 * properties having the common URI stem <code>base</code> and prefix
 * <code>prefix</code>
 * 
 * @param clazz
 *          the enumeration backing this vocabulary.
 * @param base
 *          the common stem URI of properties in this vocabulary.
 * @param prefix
 *          the common prefix of properties in this vocabulary.
 */
public EnumVocab(final Class<P> clazz, final String base, final String prefix)
{
  this.uri = Strings.nullToEmpty(base);
  this.index = ImmutableMap
      .copyOf(Maps.transformEntries(Maps.uniqueIndex(EnumSet.allOf(clazz), ENUM_TO_NAME),
          new EntryTransformer<String, P, Property>()
          {

            @Override
            public Property transformEntry(String name, P enumee)
            {
              return Property.newFrom(name, base, prefix, enumee);
            }

          }));
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
/**
 * Scopes the given callable inside a request scope. This is not the same
 * as the HTTP request scope, but is used if no HTTP request scope is in
 * progress. In this way, keys can be scoped as @RequestScoped and exist
 * in non-HTTP requests (for example: RPC requests) as well as in HTTP
 * request threads.
 *
 * <p>The returned callable will throw a {@link ScopingException} when called
 * if there is a request scope already active on the current thread.
 *
 * @param callable code to be executed which depends on the request scope.
 *     Typically in another thread, but not necessarily so.
 * @param seedMap the initial set of scoped instances for Guice to seed the
 *     request scope with.  To seed a key with null, use {@code null} as
 *     the value.
 * @return a callable that when called will run inside the a request scope
 *     that exposes the instances in the {@code seedMap} as scoped keys.
 * @since 3.0
 */
public static <T> Callable<T> scopeRequest(final Callable<T> callable,
    Map<Key<?>, Object> seedMap) {
  Preconditions.checkArgument(null != seedMap,
      "Seed map cannot be null, try passing in Collections.emptyMap() instead.");

  // Copy the seed values into our local scope map.
  final Context context = new Context();
  Map<Key<?>, Object> validatedAndCanonicalizedMap =
      Maps.transformEntries(seedMap, new EntryTransformer<Key<?>, Object, Object>() {
        @Override public Object transformEntry(Key<?> key, Object value) {
          return validateAndCanonicalizeValue(key, value);
        }
      });
  context.map.putAll(validatedAndCanonicalizedMap);

  return new Callable<T>() {
    public T call() throws Exception {
      checkScopingState(null == GuiceFilter.localContext.get(),
          "An HTTP request is already in progress, cannot scope a new request in this thread.");
      checkScopingState(null == requestScopeContext.get(),
          "A request scope is already in progress, cannot scope a new request in this thread.");
      return context.call(callable);
    }
  };
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@Override
Map<K, Collection<V2>> createAsMap() {
  return Maps.transformEntries(
      fromMultimap.asMap(),
      new EntryTransformer<K, Collection<V1>, Collection<V2>>() {
        @Override
        public Collection<V2> transformEntry(K key, Collection<V1> value) {
          return transform(key, value);
        }
      });
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
public void testTransformEntries() {
  Map<String, String> map = ImmutableMap.of("a", "4", "b", "9");
  EntryTransformer<String, String, String> concat =
      new EntryTransformer<String, String, String>() {
        @Override
        public String transformEntry(String key, String value) {
          return key + value;
        }
      };
  Map<String, String> transformed = transformEntries(map, concat);

  assertEquals(ImmutableMap.of("a", "a4", "b", "b9"), transformed);
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
public void testTransformEntriesExample() {
  Map<String, Boolean> options =
      ImmutableMap.of("verbose", true, "sort", false);
  EntryTransformer<String, Boolean, String> flagPrefixer =
      new EntryTransformer<String, Boolean, String>() {
        @Override
        public String transformEntry(String key, Boolean value) {
          return value ? key : "no" + key;
        }
      };
  Map<String, String> transformed = transformEntries(options, flagPrefixer);
  assertEquals("{verbose=verbose, sort=nosort}", transformed.toString());
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@GwtIncompatible // NavigableMap
public void testNavigableMapTransformEntries() {
  NavigableMap<String, String> map =
      ImmutableSortedMap.of("a", "4", "b", "9");
  EntryTransformer<String, String, String> concat =
      new EntryTransformer<String, String, String>() {
        @Override
        public String transformEntry(String key, String value) {
          return key + value;
        }
      };
  NavigableMap<String, String> transformed = transformEntries(map, concat);

  assertEquals(ImmutableSortedMap.of("a", "a4", "b", "b9"), transformed);
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@Override
Map<K, Collection<V2>> createAsMap() {
  return Maps.transformEntries(fromMultimap.asMap(), new EntryTransformer<K, Collection<V1>, Collection<V2>>() {
                                                       @Override
                                                       public Collection<V2> transformEntry(K key, Collection<V1> value) {
                                                         return transform(key, value);
                                                       }
                                                     });
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@Override
protected RequestRouter createRequestRouter(final Registry registry, final GlobalConfiguration globalConfiguration) {
  final Dispatcher dispatcher = createDispatcher(globalConfiguration.getDispatcherClass());
  return new RequestRouter(registry, globalConfiguration, dispatcher)
  {
    @Override
    public void processPollRequest(final Reader reader, final Writer writer, final String pathInfo)
        throws IOException
    {
      new PollRequestProcessor(registry, dispatcher, globalConfiguration)
      {
        @Override
        // HACK: we determine parameters from request not by reading request content as request content could had
        // been already read exactly for getting the params, case when request content is already empty
        protected Object[] getParameters()
        {
          if (reader instanceof RequestBoundReader) {
            ServletRequest request = ((RequestBoundReader) reader).getRequest();
            Map<String, String[]> parameterMap = request.getParameterMap();
            Map<String, String> parameters = Maps.newHashMap();
            if (parameterMap != null) {
              parameters = Maps.transformEntries(parameterMap, new EntryTransformer<String, String[], String>()
              {
                @Override
                public String transformEntry(@Nullable final String key, @Nullable final String[] values) {
                  return values == null || values.length == 0 ? null : values[0];
                }
              });
            }
            return new Object[]{parameters};
          }
          return super.getParameters();
        }
      }.process(reader, writer, pathInfo);
    }
  };
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
/**
 * @param brokers in multiple clusters, keyed by cluster id
 * @param topic
 * @return Get the partition metadata list for the specific topic via the brokers
 * null if topic is not found
 */
public static Map<String, List<PartitionMetadata>> getPartitionsForTopic(SetMultimap<String, String> brokers, final String topic)
{
  return Maps.transformEntries(brokers.asMap(), new EntryTransformer<String, Collection<String>, List<PartitionMetadata>>()
  {
    @Override
    public List<PartitionMetadata> transformEntry(String key, Collection<String> bs)
    {
      return getPartitionsForTopic(new HashSet<String>(bs), topic);
    }
  });
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
private EntryTransformer<String, Object, PropertyValue> toPropertyValue() {
    return new EntryTransformer<String, Object, PropertyValue>() {

        @Override
        public PropertyValue transformEntry(String paramName, Object value) {
            return propertyValues.containsKey(paramName) ? propertyValues.get(paramName) : createPropertyValue(getParameterType(paramName), value);
        }
    };
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@Override
Map<K, Collection<V2>> createAsMap() {
  return Maps.transformEntries(fromMultimap.asMap(),
      new EntryTransformer<K, Collection<V1>, Collection<V2>>() {
    @Override public Collection<V2> transformEntry(
        K key, Collection<V1> value) {
      return transform(key, value);
    }
  });
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
static <K, V1, V2> SortedMap<K, V2> mapsTransformEntriesSortedMap(
    SortedMap<K, V1> fromMap,
    EntryTransformer<? super K, ? super V1, V2> transformer) {
  return (fromMap instanceof NavigableMap)
      ? Maps.transformEntries((NavigableMap<K, V1>) fromMap, transformer)
      : Maps.transformEntriesIgnoreNavigable(fromMap, transformer);
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@Override
Map<K, Collection<V2>> createAsMap() {
  return Maps.transformEntries(fromMultimap.asMap(),
      new EntryTransformer<K, Collection<V1>, Collection<V2>>() {

    @Override public Collection<V2> transformEntry(
        K key, Collection<V1> value) {
      return transform(key, value);
    }
  });
}
 

import com.google.common.collect.Maps.EntryTransformer; //导入依赖的package包/类
@Override public Map<K, Collection<V2>> asMap() {
  if (asMap == null) {
    Map<K, Collection<V2>> aM = Maps.transformEntries(fromMultimap.asMap(),
        new EntryTransformer<K, Collection<V1>, Collection<V2>>() {

          @Override public Collection<V2> transformEntry(
              K key, Collection<V1> value) {
            return transform(key, value);
          }
        });
    asMap = aM;
    return aM;
  }
  return asMap;
}