com.google.common.collect.Maps Maven / Gradle / Ivy
/*
* Copyright (C) 2007 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.collect;
import com.google.common.base.Function;
import com.google.common.base.Nullable;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.MapConstraints.ConstrainedMap;
import java.io.Serializable;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumMap;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
/**
* Provides static methods for creating mutable {@code Map} instances easily.
* You can replace code like:
*
* {@code Map map = new HashMap();}
*
* with just:
*
*
{@code Map map = Maps.newHashMap();}
*
* Supported today are: {@link HashMap}, {@link LinkedHashMap}, {@link
* ConcurrentHashMap}, {@link TreeMap}, and {@link EnumMap}.
*
*
See also this class's counterparts {@link Lists} and {@link Sets}.
*
*
WARNING: These factories do not support the full variety of tuning
* parameters available in the collection constructors. Use them only for
* collections which will always remain small, or for which the cost of future
* growth operations is not a concern.
*
* @author Kevin Bourrillion
* @author Mike Bostock
*/
public final class Maps {
private Maps() {}
/**
* Creates a {@code HashMap} instance.
*
*
Note: if {@code K} is an {@code enum} type, use {@link
* #newEnumMap} instead.
*
*
Note: if you don't actually need the resulting map to be mutable,
* use {@link Collections#emptyMap} instead.
*
* @return a newly-created, initially-empty {@code HashMap}
*/
public static HashMap newHashMap() {
return new HashMap();
}
/**
* Creates a {@code HashMap} instance with enough capacity to hold the
* specified number of elements without rehashing.
*
* @param expectedSize the expected size
* @return a newly-created {@code HashMap}, initially-empty, with enough
* capacity to hold {@code expectedSize} elements without rehashing.
* @throws IllegalArgumentException if {@code expectedSize} is negative
*/
public static HashMap newHashMapWithExpectedSize(
int expectedSize) {
return new HashMap(capacity(expectedSize));
}
/**
* Returns an appropriate value for the "capacity" (in reality, "minimum
* table size") parameter of a HashMap constructor, such that the resulting
* table will be between 25% and 50% full when it contains
* {@code expectedSize} entries.
*
* @throws IllegalArgumentException if {@code expectedSize} is negative
*/
static int capacity(int expectedSize) {
checkArgument(expectedSize >= 0);
return Math.max(expectedSize * 2, 16);
}
/**
* Creates a {@code HashMap} instance with the same mappings as the specified
* map.
*
* Note: if {@code K} is an {@link Enum} type, use {@link
* #newEnumMap} instead.
*
* @param map the mappings to be placed in the new map
* @return a newly-created {@code HashMap} initialized with the mappings from
* {@code map}
*/
public static HashMap newHashMap(Map map) {
return new HashMap(map);
}
/**
* Creates an insertion-ordered {@code LinkedHashMap} instance.
*
* @return a newly-created, initially-empty {@code LinkedHashMap}
*/
public static LinkedHashMap newLinkedHashMap() {
return new LinkedHashMap();
}
/**
* Creates an insertion-ordered {@code LinkedHashMap} instance with the same
* mappings as the specified map.
*
* @param map the mappings to be placed in the new map
* @return a newly-created, {@code LinkedHashMap} initialized with the
* mappings from {@code map}
*/
public static LinkedHashMap newLinkedHashMap(Map map) {
return new LinkedHashMap(map);
}
/**
* Creates a {@code ConcurrentHashMap} instance.
*
* @return a newly-created, initially-empty {@code ConcurrentHashMap}
*/
public static ConcurrentHashMap newConcurrentHashMap() {
return new ConcurrentHashMap();
}
/**
* Creates a {@code TreeMap} instance using the natural-order {@code
* Comparator}. Note: If {@code K} is an {@link Enum} type, and you
* don't require the map to implement {@link SortedMap} (only ordered
* iteration), use {@link #newEnumMap} instead.
*
* @return a newly-created, initially-empty {@code TreeMap}
*/
@SuppressWarnings("unchecked") // allow ungenerified Comparable types
public static TreeMap newTreeMap() {
return new TreeMap();
}
/**
* Creates a {@code TreeMap} instance using the given comparator.
*
* @param comparator the Comparator to sort the keys with
* @return a newly-created, initially-empty {@code TreeMap}
*/
public static TreeMap newTreeMap(
@Nullable Comparator comparator) {
// Ideally, the extra type parameter "C" shouldn't be necessary. It is a
// work-around of a compiler type inference quirk that prevents the
// following code from being compiled:
// Comparator> comparator = null;
// Map, String> map = newTreeMap(comparator);
return new TreeMap(comparator);
}
/**
* Creates an {@code EnumMap} instance.
*
* @param type the key type for this map
* @return a newly-created, initially-empty {@code EnumMap}
*/
public static , V> EnumMap newEnumMap(Class type) {
return new EnumMap(type);
}
/**
* Creates a {@code IdentityHashMap} instance.
*
* @return a newly-created, initially-empty {@code IdentityHashMap}
*/
public static IdentityHashMap newIdentityHashMap() {
return new IdentityHashMap();
}
/**
* Returns {@code true} if {@code map} contains an entry mapping {@code key}
* to {@code value}. If you are not concerned with null-safety you can simply
* use {@code map.get(key).equals(value)}.
*/
public static boolean containsEntry(
Map map, @Nullable Object key, @Nullable Object value) {
Object valueForKey = map.get(key);
return (valueForKey == null)
? value == null && map.containsKey(key)
: valueForKey.equals(value);
}
/**
* Creates a new immutable empty {@code Map} instance.
*
* @see Collections#emptyMap
*/
public static Map immutableMap() {
return Collections.emptyMap();
}
/**
* Creates a new immutable {@code Map} instance containing the given key-value
* pair.
*
* @see Collections#singletonMap
*/
public static Map immutableMap(
@Nullable K k1, @Nullable V v1) {
return Collections.singletonMap(k1, v1);
}
/**
* Creates a new immutable {@code Map} instance containing the given key-value
* pairs.
*
* @see ImmutableMapBuilder
*/
public static Map immutableMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2) {
return new ImmutableMapBuilder()
.put(k1, v1)
.put(k2, v2)
.getMap();
}
/**
* Creates a new immutable {@code Map} instance containing the given key-value
* pairs.
*
* @see ImmutableMapBuilder
*/
public static Map immutableMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2,
@Nullable K k3, @Nullable V v3) {
return new ImmutableMapBuilder()
.put(k1, v1)
.put(k2, v2)
.put(k3, v3)
.getMap();
}
/**
* Creates a new immutable {@code Map} instance containing the given key-value
* pairs.
*
* @see ImmutableMapBuilder
*/
public static Map immutableMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2,
@Nullable K k3, @Nullable V v3,
@Nullable K k4, @Nullable V v4) {
return new ImmutableMapBuilder()
.put(k1, v1)
.put(k2, v2)
.put(k3, v3)
.put(k4, v4)
.getMap();
}
/**
* Creates a new immutable {@code Map} instance containing the given key-value
* pairs.
*
* @see ImmutableMapBuilder
*/
public static Map immutableMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2,
@Nullable K k3, @Nullable V v3,
@Nullable K k4, @Nullable V v4,
@Nullable K k5, @Nullable V v5) {
return new ImmutableMapBuilder()
.put(k1, v1)
.put(k2, v2)
.put(k3, v3)
.put(k4, v4)
.put(k5, v5)
.getMap();
}
/*
* Please use ImmutableMapBuilder directly if you are looking for overloads
* for 6 or more key-value pairs.
*/
/**
* Creates a new immutable empty {@code BiMap} instance.
*/
public static BiMap immutableBiMap() {
return new ImmutableBiMapBuilder().getBiMap();
}
/**
* Creates a new immutable {@code BiMap} instance containing the given
* key-value pair.
*/
public static BiMap immutableBiMap(
@Nullable K k1, @Nullable V v1) {
return new ImmutableBiMapBuilder()
.put(k1, v1)
.getBiMap();
}
/**
* Creates a new immutable {@code BiMap} instance containing the given
* key-value pairs.
*
* @see ImmutableBiMapBuilder
*/
public static BiMap immutableBiMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2) {
return new ImmutableBiMapBuilder()
.put(k1, v1)
.put(k2, v2)
.getBiMap();
}
/**
* Creates a new immutable {@code BiMap} instance containing the given
* key-value pairs.
*
* @see ImmutableBiMapBuilder
*/
public static BiMap immutableBiMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2,
@Nullable K k3, @Nullable V v3) {
return new ImmutableBiMapBuilder()
.put(k1, v1)
.put(k2, v2)
.put(k3, v3)
.getBiMap();
}
/**
* Creates a new immutable {@code BiMap} instance containing the given
* key-value pairs.
*
* @see ImmutableBiMapBuilder
*/
public static BiMap immutableBiMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2,
@Nullable K k3, @Nullable V v3,
@Nullable K k4, @Nullable V v4) {
return new ImmutableBiMapBuilder()
.put(k1, v1)
.put(k2, v2)
.put(k3, v3)
.put(k4, v4)
.getBiMap();
}
/**
* Creates a new immutable {@code BiMap} instance containing the given
* key-value pairs.
*
* @see ImmutableBiMapBuilder
*/
public static BiMap immutableBiMap(
@Nullable K k1, @Nullable V v1,
@Nullable K k2, @Nullable V v2,
@Nullable K k3, @Nullable V v3,
@Nullable K k4, @Nullable V v4,
@Nullable K k5, @Nullable V v5) {
return new ImmutableBiMapBuilder()
.put(k1, v1)
.put(k2, v2)
.put(k3, v3)
.put(k4, v4)
.put(k5, v5)
.getBiMap();
}
/*
* Please use ImmutableBiMapBuilder directly if you are looking for overloads
* for 6 or more key-value pairs.
*/
/**
* Returns a synchronized (thread-safe) bimap backed by the specified bimap.
* In order to guarantee serial access, it is critical that all access
* to the backing bimap is accomplished through the returned bimap.
*
* It is imperative that the user manually synchronize on the returned map
* when accessing any of its collection views:
*
*
Bimap<K,V> m = Maps.synchronizedBiMap(
* new HashBiMap<K,V>());
* ...
* Set<K> s = m.keySet(); // Needn't be in synchronized block
* ...
* synchronized (m) { // Synchronizing on m, not s!
* Iterator<K> i = s.iterator(); // Must be in synchronized block
* while (i.hasNext()) {
* foo(i.next());
* }
* }
*
* Failure to follow this advice may result in non-deterministic behavior.
*
* @param bimap the bimap to be wrapped in a synchronized view
* @return a sychronized view of the specified bimap
*/
public static BiMap synchronizedBiMap(BiMap bimap) {
return Synchronized.biMap(bimap, null);
}
/**
* Returns a sorted set view of the keys contained in the specified map. The
* set is backed by the map, so changes to the map are reflected in the set,
* and vice versa. If the map is modified while an iteration over the set is
* in progress (except through the iterator's own {@code remove} operation),
* the results of the iteration are undefined. The set supports element
* removal, which removes the corresponding mapping from the map, via the
* {@code Iterator.remove}, {@code Set.remove}, {@code removeAll}, {@code
* removeAll}, and {@code clear} operations. It does not support the add or
* {@code addAll} operations.
*
* @return a sorted set view of the keys contained in the specified map.
*/
public static SortedSet sortedKeySet(SortedMap map) {
return new SortedMapKeySet(map);
}
private static class SortedMapKeySet extends ForwardingSet
implements SortedSet {
final SortedMap map;
SortedMapKeySet(SortedMap map) {
super(map.keySet());
this.map = map;
}
public Comparator comparator() {
return map.comparator();
}
public K first() {
return map.firstKey();
}
public SortedSet headSet(K toElement) {
return new SortedMapKeySet(map.headMap(toElement));
}
public K last() {
return map.lastKey();
}
public SortedSet subSet(K fromElement, K toElement) {
return new SortedMapKeySet(map.subMap(fromElement, toElement));
}
public SortedSet tailSet(K fromElement) {
return new SortedMapKeySet(map.tailMap(fromElement));
}
}
/**
* Creates an index {@code Map} that contains the results of applying a
* specified function to each item in an {@code Iterable} of values. Each
* value will be stored as a value in the resulting map. The key used to store
* that value in the map will be the result of calling the function on that
* value. Neither keys nor values are allowed to be null. It is an error if
* the function produces the same key for more than one value in the input
* collection.
*
* @param values the values to use when constructing the {@code Map}
* @param keyFunction the function used to produce the key for each value
* @return a map mapping the result of evaluating the function {@code
* keyFunction} on each value in the input collection to that value
* @throws IllegalArgumentException if {@code keyFunction} produces the same
* key for more than one value in the input collection
* @throws NullPointerException if any elements of {@code values} are null, or
* if {@code keyFunction} produces {@code null} for any value
*/
public static Map uniqueIndex(Iterable values,
Function keyFunction) {
HashMap newMap;
if (values instanceof Collection) {
// If it's really a collection, take advantage of knowing the size
@SuppressWarnings("unchecked")
Collection collection = (Collection) values;
newMap = new HashMap(collection.size());
} else {
newMap = new HashMap();
}
return uniqueIndex(newMap, values.iterator(), keyFunction);
}
/**
* Creates an index {@code Map} that contains the results of applying a
* specified function to each item in a {@code Collection} of values. Each
* value will be stored as a value in the resulting map. The key used to store
* that value in the map will be the result of calling the function on that
* value. Neither keys nor values are allowed to be null. It is an error if
* the function produces the same key for more than one value in the input
* collection.
*
* @param values the values to use when constructing the {@code Map}
* @param keyFunction the function used to produce the key for each value
* @return {@code Map} mapping the result of evaluating the function {@code
* keyFunction} on each value in the input collection to that value
* @throws IllegalArgumentException if {@code keyFunction} produces the same
* key for more than one value in the input collection
* @throws NullPointerException if any elements of {@code values} are null, or
* if {@code keyFunction} produces {@code null} for any value
*/
public static Map uniqueIndex(Collection values,
Function keyFunction) {
return uniqueIndex(new HashMap(values.size() * 2),
values.iterator(), keyFunction);
}
/**
* Creates an index {@code Map} that contains the results of applying a
* specified function to each item in an {@code Iterator} of values. Each
* value will be stored as a value in the resulting map. The key used to store
* that value in the map will be the result of calling the function on that
* value. Neither keys nor values are allowed to be null. It is an error if
* the function produces the same key for more than one value in the input
* collection.
*
* @param values the values to use when constructing the {@code Map}
* @param keyFunction the function used to produce the key for each value
* @return {@code Map} mapping the result of evaluating the function {@code
* keyFunction} on each value in the input collection to that value
* @throws IllegalArgumentException if {@code keyFunction} produces the same
* key for more than one value in the input collection
* @throws NullPointerException if any elements of {@code values} are null, or
* if {@code keyFunction} produces {@code null} for any value
*/
public static Map uniqueIndex(Iterator values,
Function keyFunction) {
return uniqueIndex(new HashMap(), values, keyFunction);
}
private static Map uniqueIndex(
Map map, Iterator values,
Function keyFunction) {
checkNotNull(keyFunction);
while (values.hasNext()) {
V value = checkNotNull(values.next(), "null index values not allowed");
K key = checkNotNull(keyFunction.apply(value),
"null index keys not allowed");
checkArgument(map.put(key, value) == null, "Duplicate key: %s", key);
}
return map;
}
/**
* Creates a {@code Map} from a {@code Properties} instance.
* Properties normally derive from {@code Map}, but they
* typically contain strings, which is awkward. This method lets you get a
* plain-old-{@code Map} out of a {@code Properties}. Note that you won't be
* able to save the changes to the Map the way you can with {@link
* Properties#store(java.io.OutputStream,String)}. Most people don't do this
* anyway.
*
* @param prop a {@code Properties} object to be converted.
* @return a {@code Map} containing all the entries in the
* Properties object. Note that {@code Properties} does not allow the key
* or value to be null.
*/
public static Map fromProperties(Properties prop) {
Map ret = newHashMapWithExpectedSize(prop.size());
for (Enumeration e = prop.propertyNames(); e.hasMoreElements();) {
Object k = e.nextElement();
/*
* It is unlikely that a 'null' could be inserted into a Properties, but
* possible in a derived class.
*/
String key = (k != null) ? k.toString() : null;
ret.put(key, prop.getProperty(key));
}
return ret;
}
/**
* Returns an immutable map entry with the specified key and value. The {@link
* Entry#setValue} operation throws an {@link UnsupportedOperationException}.
*
* The returned entry is serializable.
*
* @param key the key to be associated with the returned entry
* @param value the value to be associated with the returned entry
*/
public static Entry immutableEntry(
@Nullable final K key, @Nullable final V value) {
return new ImmutableEntry(key, value);
}
/** @see Maps#immutableEntry(Object,Object) */
private static class ImmutableEntry extends AbstractMapEntry
implements Serializable {
final K key;
final V value;
ImmutableEntry(K key, V value) {
this.key = key;
this.value = value;
}
@Override public K getKey() {
return key;
}
@Override public V getValue() {
return value;
}
private static final long serialVersionUID = 8715539841043489689L;
}
/**
* Returns an unmodifiable view of the specified set of entries. The {@link
* Entry#setValue} operation throws an {@link UnsupportedOperationException},
* as do any operations that would modify the returned set.
*
* @param entrySet the entries for which to return an unmodifiable view
* @return an unmodifiable view of the entries
*/
static Set> unmodifiableEntrySet(
final Set> entrySet) {
return new UnmodifiableEntrySet(Collections.unmodifiableSet(
entrySet));
}
/**
* Returns an unmodifiable view of the specified map entry. The {@link
* Entry#setValue} operation throws an {@link UnsupportedOperationException}.
* This also has the side-effect of redefining {@code equals} to comply with
* the Entry contract, to avoid a possible nefarious implementation of
* equals.
*
* @param entry the entry for which to return an unmodifiable view
* @return an unmodifiable view of the entry
*/
private static Entry unmodifiableEntry(final Entry entry) {
checkNotNull(entry);
return new AbstractMapEntry() {
@Override public K getKey() {
return entry.getKey();
}
@Override public V getValue() {
return entry.getValue();
}
};
}
/** @see Multimaps#unmodifiableEntries */
static class UnmodifiableEntries
extends ForwardingCollection> {
UnmodifiableEntries(Collection> entries) {
super(entries);
}
@Override public Iterator> iterator() {
return new ForwardingIterator>(super.iterator()) {
@Override public Entry next() {
return unmodifiableEntry(super.next());
}
};
}
// See java.util.Collections.UnmodifiableEntrySet for details on attacks.
@Override public Object[] toArray() {
return toArrayImpl(this);
}
@Override public T[] toArray(T[] array) {
return toArrayImpl(this, array);
}
@Override public boolean contains(Object o) {
return containsEntryImpl(delegate(), o);
}
@Override public boolean containsAll(Collection c) {
return containsAllImpl(this, c);
}
}
/** @see Maps#unmodifiableEntrySet(Set) */
static class UnmodifiableEntrySet
extends UnmodifiableEntries
implements Set> {
UnmodifiableEntrySet(Set> entries) {
super(entries);
}
// See java.util.Collections.UnmodifiableEntrySet for details on attacks.
@Override public boolean equals(Object o) {
return ForwardingSet.equalsImpl(this, o);
}
}
/**
* Returns a new empty {@code HashBiMap} with the default initial capacity
* (16) and load factor (0.75).
*/
public static HashBiMap newHashBiMap() {
return new HashBiMap();
}
/**
* Returns a new empty {@code EnumHashBiMap} using the specified key type,
* sized to contain an entry for every possible key.
*
* @param keyType the key type
*/
public static , V> EnumHashBiMap newEnumHashBiMap(
Class keyType) {
return new EnumHashBiMap(keyType);
}
/**
* Returns a new empty {@code EnumBiMap} using the specified key type and
* value type.
*
* @param keyType the key type
* @param valueType the value type
*/
public static , V extends Enum> EnumBiMap
newEnumBiMap(Class keyType, Class valueType) {
return new EnumBiMap(keyType, valueType);
}
/**
* Returns a new {@code BiMap}, backed by the two supplied empty maps. The
* caller surrenders control of these maps and should not retain any
* references to either.
*
* The returned bimap will be serializable if both of the specified maps
* are serializable.
*
* @param forward an empty map to be used for associating keys with values
* @param backward an empty map to be used for associating values with keys
* @throws IllegalArgumentException if either map is nonempty
*/
public static BiMap newBiMap(
Map forward, Map backward) {
return new StandardBiMap(forward, backward);
}
/**
* Returns an unmodifiable view of the specified bimap. This method allows
* modules to provide users with "read-only" access to internal bimaps. Query
* operations on the returned bimap "read through" to the specified bimap, and
* attemps to modify the returned map, whether direct or via its collection
* views, result in an {@code UnsupportedOperationException}.
*
* The returned bimap will be serializable if the specified map is
* serializable.
*
* @param bimap the bimap for which an unmodifiable view is to be returned
* @return an unmodifiable view of the specified bimap
*/
public static BiMap unmodifiableBiMap(BiMap bimap) {
return new UnmodifiableBiMap(bimap, null);
}
/** @see Maps#unmodifiableBiMap(BiMap) */
private static class UnmodifiableBiMap extends ForwardingMap
implements BiMap {
final BiMap delegate;
transient volatile BiMap inverse;
UnmodifiableBiMap(BiMap delegate, BiMap inverse) {
super(Collections.unmodifiableMap(delegate));
this.delegate = delegate;
this.inverse = inverse;
}
public V forcePut(K key, V value) {
throw new UnsupportedOperationException();
}
public BiMap inverse() {
if (inverse == null) {
inverse = new UnmodifiableBiMap(delegate.inverse(), this);
}
return inverse;
}
@Override public Set values() {
return Collections.unmodifiableSet(delegate.values());
}
private static final long serialVersionUID = 9106827410356097381L;
}
/**
* Returns a new {@code ClassToInstanceMap} instance backed by a {@link
* HashMap} using the default initial capacity and load factor.
*/
public static ClassToInstanceMap newClassToInstanceMap() {
return newClassToInstanceMap(new HashMap, B>());
}
/**
* Returns a new {@code ClassToInstanceMap} instance backed by a given empty
* {@code backingMap}. The caller surrenders control of the backing map, and
* thus should not allow any direct references to it to remain accessible.
*/
public static ClassToInstanceMap newClassToInstanceMap(
Map, B> backingMap) {
return new SimpleClassToInstanceMap(backingMap);
}
private static final MapConstraint, Object> VALUE_CAN_BE_CAST_TO_KEY
= new MapConstraint, Object>() {
public void checkKeyValue(Class key, Object value) {
wrap(key).cast(value);
}
};
// TODO: should be a public final class like the rest, right?
private static class SimpleClassToInstanceMap extends
ConstrainedMap, B> implements ClassToInstanceMap {
SimpleClassToInstanceMap(Map, B> delegate) {
super(delegate, VALUE_CAN_BE_CAST_TO_KEY);
}
public T putInstance(Class type, T value) {
B oldValue = put(type, value);
return wrap(type).cast(oldValue);
}
public T getInstance(Class type) {
B value = get(type);
return wrap(type).cast(value);
}
private static final long serialVersionUID = 3549975116715378971L;
}
@SuppressWarnings("unchecked")
private static Class wrap(Class c) {
return c.isPrimitive() ? (Class) PRIMITIVES_TO_WRAPPERS.get(c) : c;
}
private static final Map, Class> PRIMITIVES_TO_WRAPPERS
= new ImmutableMapBuilder, Class>(9)
.put(boolean.class, Boolean.class)
.put(byte.class, Byte.class)
.put(char.class, Character.class)
.put(double.class, Double.class)
.put(float.class, Float.class)
.put(int.class, Integer.class)
.put(long.class, Long.class)
.put(short.class, Short.class)
.put(void.class, Void.class)
.getMap();
/**
* Implements {@code Collection.contains} safely for forwarding collections of
* map entries. If {@code o} is an instance of {@code Map.Entry}, it is
* wrapped using {@link #unmodifiableEntry} to protect against a possible
* nefarious equals method.
*
* Note that {@code c} is the backing (delegate) collection, rather than
* the forwarding collection.
*
* @param c the delegate (unwrapped) collection of map entries
* @param o the object that might be contained in {@code c}
* @return {@code true} if {@code c} contains {@code o}
*/
@SuppressWarnings("unchecked")
static boolean containsEntryImpl(Collection> c, Object o) {
if (!(o instanceof Entry)) {
return false;
}
return c.contains(unmodifiableEntry((Entry) o));
}
/**
* Implements {@code Collection.remove} safely for forwarding collections of
* map entries. If {@code o} is an instance of {@code Map.Entry}, it is
* wrapped using {@link #unmodifiableEntry} to protect against a possible
* nefarious equals method.
*
* Note that {@code c} is backing (delegate) collection, rather than the
* forwarding collection.
*
* @param c the delegate (unwrapped) collection of map entries
* @param o the object to remove from {@code c}
* @return {@code true} if {@code c} was changed
*/
@SuppressWarnings("unchecked")
static boolean removeEntryImpl(Collection> c, Object o) {
if (!(o instanceof Entry)) {
return false;
}
return c.remove(unmodifiableEntry((Entry) o));
}
}