4134 lines
127 KiB
Java
4134 lines
127 KiB
Java
/*
|
|
* Copyright (C) 2007 The Guava Authors
|
|
*
|
|
* 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 static com.google.common.base.Preconditions.checkArgument;
|
|
import static com.google.common.base.Preconditions.checkNotNull;
|
|
import static com.google.common.base.Predicates.compose;
|
|
import static com.google.common.base.Predicates.equalTo;
|
|
import static com.google.common.base.Predicates.in;
|
|
import static com.google.common.base.Predicates.not;
|
|
import static com.google.common.collect.CollectPreconditions.checkNonnegative;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.AbstractCollection;
|
|
import java.util.AbstractMap;
|
|
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.NavigableMap;
|
|
import java.util.NavigableSet;
|
|
import java.util.Properties;
|
|
import java.util.Set;
|
|
import java.util.SortedMap;
|
|
import java.util.SortedSet;
|
|
import java.util.TreeMap;
|
|
|
|
import javax.annotation.Nullable;
|
|
|
|
import com.google.common.annotations.Beta;
|
|
import com.google.common.annotations.GwtCompatible;
|
|
import com.google.common.annotations.GwtIncompatible;
|
|
import com.google.common.base.Converter;
|
|
import com.google.common.base.Equivalence;
|
|
import com.google.common.base.Function;
|
|
import com.google.common.base.Joiner.MapJoiner;
|
|
import com.google.common.base.Objects;
|
|
import com.google.common.base.Preconditions;
|
|
import com.google.common.base.Predicate;
|
|
import com.google.common.base.Predicates;
|
|
import com.google.common.collect.MapDifference.ValueDifference;
|
|
import com.google.common.primitives.Ints;
|
|
|
|
/**
|
|
* Static utility methods pertaining to {@link Map} instances (including
|
|
* instances of {@link SortedMap}, {@link BiMap}, etc.). Also see this class's
|
|
* counterparts {@link Lists}, {@link Sets} and {@link Queues}.
|
|
*
|
|
* <p>
|
|
* See the Guava User Guide article on <a href=
|
|
* "http://code.google.com/p/guava-libraries/wiki/CollectionUtilitiesExplained#Maps">
|
|
* {@code Maps}</a>.
|
|
*
|
|
* @author Kevin Bourrillion
|
|
* @author Mike Bostock
|
|
* @author Isaac Shum
|
|
* @author Louis Wasserman
|
|
* @since 2.0 (imported from Google Collections Library)
|
|
*/
|
|
@GwtCompatible(emulated = true)
|
|
public final class Maps {
|
|
private Maps() {
|
|
}
|
|
|
|
private enum EntryFunction implements Function<Entry<?, ?>, Object> {
|
|
KEY {
|
|
@Override
|
|
@Nullable
|
|
public Object apply(Entry<?, ?> entry) {
|
|
return entry.getKey();
|
|
}
|
|
},
|
|
VALUE {
|
|
@Override
|
|
@Nullable
|
|
public Object apply(Entry<?, ?> entry) {
|
|
return entry.getValue();
|
|
}
|
|
};
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
static <K> Function<Entry<K, ?>, K> keyFunction() {
|
|
return (Function) EntryFunction.KEY;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
static <V> Function<Entry<?, V>, V> valueFunction() {
|
|
return (Function) EntryFunction.VALUE;
|
|
}
|
|
|
|
static <K, V> Iterator<K> keyIterator(Iterator<Entry<K, V>> entryIterator) {
|
|
return Iterators.transform(entryIterator, Maps.<K>keyFunction());
|
|
}
|
|
|
|
static <K, V> Iterator<V> valueIterator(Iterator<Entry<K, V>> entryIterator) {
|
|
return Iterators.transform(entryIterator, Maps.<V>valueFunction());
|
|
}
|
|
|
|
static <K, V> UnmodifiableIterator<V> valueIterator(final UnmodifiableIterator<Entry<K, V>> entryIterator) {
|
|
return new UnmodifiableIterator<V>() {
|
|
@Override
|
|
public boolean hasNext() {
|
|
return entryIterator.hasNext();
|
|
}
|
|
|
|
@Override
|
|
public V next() {
|
|
return entryIterator.next().getValue();
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns an immutable map instance containing the given entries. Internally,
|
|
* the returned map will be backed by an {@link EnumMap}.
|
|
*
|
|
* <p>
|
|
* The iteration order of the returned map follows the enum's iteration order,
|
|
* not the order in which the elements appear in the given map.
|
|
*
|
|
* @param map the map to make an immutable copy of
|
|
* @return an immutable map containing those entries
|
|
* @since 14.0
|
|
*/
|
|
@GwtCompatible(serializable = true)
|
|
@Beta
|
|
public static <K extends Enum<K>, V> ImmutableMap<K, V> immutableEnumMap(Map<K, ? extends V> map) {
|
|
if (map instanceof ImmutableEnumMap) {
|
|
@SuppressWarnings("unchecked") // safe covariant cast
|
|
ImmutableEnumMap<K, V> result = (ImmutableEnumMap<K, V>) map;
|
|
return result;
|
|
} else if (map.isEmpty()) {
|
|
return ImmutableMap.of();
|
|
} else {
|
|
for (Map.Entry<K, ? extends V> entry : map.entrySet()) {
|
|
checkNotNull(entry.getKey());
|
|
checkNotNull(entry.getValue());
|
|
}
|
|
return ImmutableEnumMap.asImmutable(new EnumMap<K, V>(map));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a <i>mutable</i>, empty {@code HashMap} instance.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if mutability is not required, use {@link ImmutableMap#of()}
|
|
* instead.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if {@code K} is an {@code enum} type, use {@link #newEnumMap}
|
|
* instead.
|
|
*
|
|
* @return a new, empty {@code HashMap}
|
|
*/
|
|
public static <K, V> HashMap<K, V> newHashMap() {
|
|
return new HashMap<K, V>();
|
|
}
|
|
|
|
/**
|
|
* Creates a {@code HashMap} instance, with a high enough "initial capacity"
|
|
* that it <i>should</i> hold {@code expectedSize} elements without growth. This
|
|
* behavior cannot be broadly guaranteed, but it is observed to be true for
|
|
* OpenJDK 1.6. It also can't be guaranteed that the method isn't inadvertently
|
|
* <i>oversizing</i> the returned map.
|
|
*
|
|
* @param expectedSize the number of elements you expect to add to the returned
|
|
* map
|
|
* @return a new, empty {@code HashMap} with enough capacity to hold {@code
|
|
* expectedSize} elements without resizing
|
|
* @throws IllegalArgumentException if {@code expectedSize} is negative
|
|
*/
|
|
public static <K, V> HashMap<K, V> newHashMapWithExpectedSize(int expectedSize) {
|
|
return new HashMap<K, V>(capacity(expectedSize));
|
|
}
|
|
|
|
/**
|
|
* Returns a capacity that is sufficient to keep the map from being resized as
|
|
* long as it grows no larger than expectedSize and the load factor is >= its
|
|
* default (0.75).
|
|
*/
|
|
static int capacity(int expectedSize) {
|
|
if (expectedSize < 3) {
|
|
checkNonnegative(expectedSize, "expectedSize");
|
|
return expectedSize + 1;
|
|
}
|
|
if (expectedSize < Ints.MAX_POWER_OF_TWO) {
|
|
return expectedSize + expectedSize / 3;
|
|
}
|
|
return Integer.MAX_VALUE; // any large value
|
|
}
|
|
|
|
/**
|
|
* Creates a <i>mutable</i> {@code HashMap} instance with the same mappings as
|
|
* the specified map.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if mutability is not required, use
|
|
* {@link ImmutableMap#copyOf(Map)} instead.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> 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 new {@code HashMap} initialized with the mappings from {@code
|
|
* map}
|
|
*/
|
|
public static <K, V> HashMap<K, V> newHashMap(Map<? extends K, ? extends V> map) {
|
|
return new HashMap<K, V>(map);
|
|
}
|
|
|
|
/**
|
|
* Creates a <i>mutable</i>, empty, insertion-ordered {@code LinkedHashMap}
|
|
* instance.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if mutability is not required, use {@link ImmutableMap#of()}
|
|
* instead.
|
|
*
|
|
* @return a new, empty {@code LinkedHashMap}
|
|
*/
|
|
public static <K, V> LinkedHashMap<K, V> newLinkedHashMap() {
|
|
return new LinkedHashMap<K, V>();
|
|
}
|
|
|
|
/**
|
|
* Creates a <i>mutable</i>, insertion-ordered {@code LinkedHashMap} instance
|
|
* with the same mappings as the specified map.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if mutability is not required, use
|
|
* {@link ImmutableMap#copyOf(Map)} instead.
|
|
*
|
|
* @param map the mappings to be placed in the new map
|
|
* @return a new, {@code LinkedHashMap} initialized with the mappings from
|
|
* {@code map}
|
|
*/
|
|
public static <K, V> LinkedHashMap<K, V> newLinkedHashMap(Map<? extends K, ? extends V> map) {
|
|
return new LinkedHashMap<K, V>(map);
|
|
}
|
|
|
|
/**
|
|
* Creates a <i>mutable</i>, empty {@code TreeMap} instance using the natural
|
|
* ordering of its elements.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if mutability is not required, use
|
|
* {@link ImmutableSortedMap#of()} instead.
|
|
*
|
|
* @return a new, empty {@code TreeMap}
|
|
*/
|
|
public static <K extends Comparable, V> TreeMap<K, V> newTreeMap() {
|
|
return new TreeMap<K, V>();
|
|
}
|
|
|
|
/**
|
|
* Creates a <i>mutable</i> {@code TreeMap} instance with the same mappings as
|
|
* the specified map and using the same ordering as the specified map.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if mutability is not required, use
|
|
* {@link ImmutableSortedMap#copyOfSorted(SortedMap)} instead.
|
|
*
|
|
* @param map the sorted map whose mappings are to be placed in the new map and
|
|
* whose comparator is to be used to sort the new map
|
|
* @return a new {@code TreeMap} initialized with the mappings from {@code
|
|
* map} and using the comparator of {@code map}
|
|
*/
|
|
public static <K, V> TreeMap<K, V> newTreeMap(SortedMap<K, ? extends V> map) {
|
|
return new TreeMap<K, V>(map);
|
|
}
|
|
|
|
/**
|
|
* Creates a <i>mutable</i>, empty {@code TreeMap} instance using the given
|
|
* comparator.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b> if mutability is not required, use {@code
|
|
* ImmutableSortedMap.orderedBy(comparator).build()} instead.
|
|
*
|
|
* @param comparator the comparator to sort the keys with
|
|
* @return a new, empty {@code TreeMap}
|
|
*/
|
|
public static <C, K extends C, V> TreeMap<K, V> newTreeMap(@Nullable Comparator<C> 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<Class<?>> comparator = null;
|
|
// Map<Class<? extends Throwable>, String> map = newTreeMap(comparator);
|
|
return new TreeMap<K, V>(comparator);
|
|
}
|
|
|
|
/**
|
|
* Creates an {@code EnumMap} instance.
|
|
*
|
|
* @param type the key type for this map
|
|
* @return a new, empty {@code EnumMap}
|
|
*/
|
|
public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(Class<K> type) {
|
|
return new EnumMap<K, V>(checkNotNull(type));
|
|
}
|
|
|
|
/**
|
|
* Creates an {@code EnumMap} with the same mappings as the specified map.
|
|
*
|
|
* @param map the map from which to initialize this {@code EnumMap}
|
|
* @return a new {@code EnumMap} initialized with the mappings from {@code
|
|
* map}
|
|
* @throws IllegalArgumentException if {@code m} is not an {@code EnumMap}
|
|
* instance and contains no mappings
|
|
*/
|
|
public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(Map<K, ? extends V> map) {
|
|
return new EnumMap<K, V>(map);
|
|
}
|
|
|
|
/**
|
|
* Creates an {@code IdentityHashMap} instance.
|
|
*
|
|
* @return a new, empty {@code IdentityHashMap}
|
|
*/
|
|
public static <K, V> IdentityHashMap<K, V> newIdentityHashMap() {
|
|
return new IdentityHashMap<K, V>();
|
|
}
|
|
|
|
/**
|
|
* Computes the difference between two maps. This difference is an immutable
|
|
* snapshot of the state of the maps at the time this method is called. It will
|
|
* never change, even if the maps change at a later time.
|
|
*
|
|
* <p>
|
|
* Since this method uses {@code HashMap} instances internally, the keys of the
|
|
* supplied maps must be well-behaved with respect to {@link Object#equals} and
|
|
* {@link Object#hashCode}.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b>If you only need to know whether two maps have the same mappings,
|
|
* call {@code left.equals(right)} instead of this method.
|
|
*
|
|
* @param left the map to treat as the "left" map for purposes of comparison
|
|
* @param right the map to treat as the "right" map for purposes of comparison
|
|
* @return the difference between the two maps
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public static <K, V> MapDifference<K, V> difference(Map<? extends K, ? extends V> left,
|
|
Map<? extends K, ? extends V> right) {
|
|
if (left instanceof SortedMap) {
|
|
SortedMap<K, ? extends V> sortedLeft = (SortedMap<K, ? extends V>) left;
|
|
SortedMapDifference<K, V> result = difference(sortedLeft, right);
|
|
return result;
|
|
}
|
|
return difference(left, right, Equivalence.equals());
|
|
}
|
|
|
|
/**
|
|
* Computes the difference between two maps. This difference is an immutable
|
|
* snapshot of the state of the maps at the time this method is called. It will
|
|
* never change, even if the maps change at a later time.
|
|
*
|
|
* <p>
|
|
* Values are compared using a provided equivalence, in the case of equality,
|
|
* the value on the 'left' is returned in the difference.
|
|
*
|
|
* <p>
|
|
* Since this method uses {@code HashMap} instances internally, the keys of the
|
|
* supplied maps must be well-behaved with respect to {@link Object#equals} and
|
|
* {@link Object#hashCode}.
|
|
*
|
|
* @param left the map to treat as the "left" map for purposes of
|
|
* comparison
|
|
* @param right the map to treat as the "right" map for purposes of
|
|
* comparison
|
|
* @param valueEquivalence the equivalence relationship to use to compare values
|
|
* @return the difference between the two maps
|
|
* @since 10.0
|
|
*/
|
|
@Beta
|
|
public static <K, V> MapDifference<K, V> difference(Map<? extends K, ? extends V> left,
|
|
Map<? extends K, ? extends V> right, Equivalence<? super V> valueEquivalence) {
|
|
Preconditions.checkNotNull(valueEquivalence);
|
|
|
|
Map<K, V> onlyOnLeft = newHashMap();
|
|
Map<K, V> onlyOnRight = new HashMap<K, V>(right); // will whittle it down
|
|
Map<K, V> onBoth = newHashMap();
|
|
Map<K, MapDifference.ValueDifference<V>> differences = newHashMap();
|
|
doDifference(left, right, valueEquivalence, onlyOnLeft, onlyOnRight, onBoth, differences);
|
|
return new MapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);
|
|
}
|
|
|
|
private static <K, V> void doDifference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right,
|
|
Equivalence<? super V> valueEquivalence, Map<K, V> onlyOnLeft, Map<K, V> onlyOnRight, Map<K, V> onBoth,
|
|
Map<K, MapDifference.ValueDifference<V>> differences) {
|
|
for (Entry<? extends K, ? extends V> entry : left.entrySet()) {
|
|
K leftKey = entry.getKey();
|
|
V leftValue = entry.getValue();
|
|
if (right.containsKey(leftKey)) {
|
|
V rightValue = onlyOnRight.remove(leftKey);
|
|
if (valueEquivalence.equivalent(leftValue, rightValue)) {
|
|
onBoth.put(leftKey, leftValue);
|
|
} else {
|
|
differences.put(leftKey, ValueDifferenceImpl.create(leftValue, rightValue));
|
|
}
|
|
} else {
|
|
onlyOnLeft.put(leftKey, leftValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static <K, V> Map<K, V> unmodifiableMap(Map<K, V> map) {
|
|
if (map instanceof SortedMap) {
|
|
return Collections.unmodifiableSortedMap((SortedMap<K, ? extends V>) map);
|
|
} else {
|
|
return Collections.unmodifiableMap(map);
|
|
}
|
|
}
|
|
|
|
static class MapDifferenceImpl<K, V> implements MapDifference<K, V> {
|
|
final Map<K, V> onlyOnLeft;
|
|
final Map<K, V> onlyOnRight;
|
|
final Map<K, V> onBoth;
|
|
final Map<K, ValueDifference<V>> differences;
|
|
|
|
MapDifferenceImpl(Map<K, V> onlyOnLeft, Map<K, V> onlyOnRight, Map<K, V> onBoth,
|
|
Map<K, ValueDifference<V>> differences) {
|
|
this.onlyOnLeft = unmodifiableMap(onlyOnLeft);
|
|
this.onlyOnRight = unmodifiableMap(onlyOnRight);
|
|
this.onBoth = unmodifiableMap(onBoth);
|
|
this.differences = unmodifiableMap(differences);
|
|
}
|
|
|
|
@Override
|
|
public boolean areEqual() {
|
|
return onlyOnLeft.isEmpty() && onlyOnRight.isEmpty() && differences.isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public Map<K, V> entriesOnlyOnLeft() {
|
|
return onlyOnLeft;
|
|
}
|
|
|
|
@Override
|
|
public Map<K, V> entriesOnlyOnRight() {
|
|
return onlyOnRight;
|
|
}
|
|
|
|
@Override
|
|
public Map<K, V> entriesInCommon() {
|
|
return onBoth;
|
|
}
|
|
|
|
@Override
|
|
public Map<K, ValueDifference<V>> entriesDiffering() {
|
|
return differences;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object object) {
|
|
if (object == this) {
|
|
return true;
|
|
}
|
|
if (object instanceof MapDifference) {
|
|
MapDifference<?, ?> other = (MapDifference<?, ?>) object;
|
|
return entriesOnlyOnLeft().equals(other.entriesOnlyOnLeft())
|
|
&& entriesOnlyOnRight().equals(other.entriesOnlyOnRight())
|
|
&& entriesInCommon().equals(other.entriesInCommon())
|
|
&& entriesDiffering().equals(other.entriesDiffering());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hashCode(entriesOnlyOnLeft(), entriesOnlyOnRight(), entriesInCommon(), entriesDiffering());
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
if (areEqual()) {
|
|
return "equal";
|
|
}
|
|
|
|
StringBuilder result = new StringBuilder("not equal");
|
|
if (!onlyOnLeft.isEmpty()) {
|
|
result.append(": only on left=").append(onlyOnLeft);
|
|
}
|
|
if (!onlyOnRight.isEmpty()) {
|
|
result.append(": only on right=").append(onlyOnRight);
|
|
}
|
|
if (!differences.isEmpty()) {
|
|
result.append(": value differences=").append(differences);
|
|
}
|
|
return result.toString();
|
|
}
|
|
}
|
|
|
|
static class ValueDifferenceImpl<V> implements MapDifference.ValueDifference<V> {
|
|
private final V left;
|
|
private final V right;
|
|
|
|
static <V> ValueDifference<V> create(@Nullable V left, @Nullable V right) {
|
|
return new ValueDifferenceImpl<V>(left, right);
|
|
}
|
|
|
|
private ValueDifferenceImpl(@Nullable V left, @Nullable V right) {
|
|
this.left = left;
|
|
this.right = right;
|
|
}
|
|
|
|
@Override
|
|
public V leftValue() {
|
|
return left;
|
|
}
|
|
|
|
@Override
|
|
public V rightValue() {
|
|
return right;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(@Nullable Object object) {
|
|
if (object instanceof MapDifference.ValueDifference) {
|
|
MapDifference.ValueDifference<?> that = (MapDifference.ValueDifference<?>) object;
|
|
return Objects.equal(this.left, that.leftValue()) && Objects.equal(this.right, that.rightValue());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hashCode(left, right);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "(" + left + ", " + right + ")";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Computes the difference between two sorted maps, using the comparator of the
|
|
* left map, or {@code Ordering.natural()} if the left map uses the natural
|
|
* ordering of its elements. This difference is an immutable snapshot of the
|
|
* state of the maps at the time this method is called. It will never change,
|
|
* even if the maps change at a later time.
|
|
*
|
|
* <p>
|
|
* Since this method uses {@code TreeMap} instances internally, the keys of the
|
|
* right map must all compare as distinct according to the comparator of the
|
|
* left map.
|
|
*
|
|
* <p>
|
|
* <b>Note:</b>If you only need to know whether two sorted maps have the same
|
|
* mappings, call {@code left.equals(right)} instead of this method.
|
|
*
|
|
* @param left the map to treat as the "left" map for purposes of comparison
|
|
* @param right the map to treat as the "right" map for purposes of comparison
|
|
* @return the difference between the two maps
|
|
* @since 11.0
|
|
*/
|
|
public static <K, V> SortedMapDifference<K, V> difference(SortedMap<K, ? extends V> left,
|
|
Map<? extends K, ? extends V> right) {
|
|
checkNotNull(left);
|
|
checkNotNull(right);
|
|
Comparator<? super K> comparator = orNaturalOrder(left.comparator());
|
|
SortedMap<K, V> onlyOnLeft = Maps.newTreeMap(comparator);
|
|
SortedMap<K, V> onlyOnRight = Maps.newTreeMap(comparator);
|
|
onlyOnRight.putAll(right); // will whittle it down
|
|
SortedMap<K, V> onBoth = Maps.newTreeMap(comparator);
|
|
SortedMap<K, MapDifference.ValueDifference<V>> differences = Maps.newTreeMap(comparator);
|
|
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
|
|
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);
|
|
}
|
|
|
|
static class SortedMapDifferenceImpl<K, V> extends MapDifferenceImpl<K, V> implements SortedMapDifference<K, V> {
|
|
SortedMapDifferenceImpl(SortedMap<K, V> onlyOnLeft, SortedMap<K, V> onlyOnRight, SortedMap<K, V> onBoth,
|
|
SortedMap<K, ValueDifference<V>> differences) {
|
|
super(onlyOnLeft, onlyOnRight, onBoth, differences);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, ValueDifference<V>> entriesDiffering() {
|
|
return (SortedMap<K, ValueDifference<V>>) super.entriesDiffering();
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> entriesInCommon() {
|
|
return (SortedMap<K, V>) super.entriesInCommon();
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> entriesOnlyOnLeft() {
|
|
return (SortedMap<K, V>) super.entriesOnlyOnLeft();
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> entriesOnlyOnRight() {
|
|
return (SortedMap<K, V>) super.entriesOnlyOnRight();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the specified comparator if not null; otherwise returns {@code
|
|
* Ordering.natural()}. This method is an abomination of generics; the only
|
|
* purpose of this method is to contain the ugly type-casting in one place.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
static <E> Comparator<? super E> orNaturalOrder(@Nullable Comparator<? super E> comparator) {
|
|
if (comparator != null) { // can't use ? : because of javac bug 5080917
|
|
return comparator;
|
|
}
|
|
return (Comparator<E>) Ordering.natural();
|
|
}
|
|
|
|
/**
|
|
* Returns a live {@link Map} view whose keys are the contents of {@code set}
|
|
* and whose values are computed on demand using {@code function}. To get an
|
|
* immutable <i>copy</i> instead, use {@link #toMap(Iterable, Function)}.
|
|
*
|
|
* <p>
|
|
* Specifically, for each {@code k} in the backing set, the returned map has an
|
|
* entry mapping {@code k} to {@code function.apply(k)}. The {@code
|
|
* keySet}, {@code values}, and {@code entrySet} views of the returned map
|
|
* iterate in the same order as the backing set.
|
|
*
|
|
* <p>
|
|
* Modifications to the backing set are read through to the returned map. The
|
|
* returned map supports removal operations if the backing set does. Removal
|
|
* operations write through to the backing set. The returned map does not
|
|
* support put operations.
|
|
*
|
|
* <p>
|
|
* <b>Warning</b>: If the function rejects {@code null}, caution is required to
|
|
* make sure the set does not contain {@code null}, because the view cannot stop
|
|
* {@code null} from being added to the set.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> This method assumes that for any instance {@code k} of key
|
|
* type {@code K}, {@code k.equals(k2)} implies that {@code k2} is also of type
|
|
* {@code K}. Using a key type for which this may not hold, such as
|
|
* {@code ArrayList}, may risk a {@code ClassCastException} when calling methods
|
|
* on the resulting map view.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
@Beta
|
|
public static <K, V> Map<K, V> asMap(Set<K> set, Function<? super K, V> function) {
|
|
if (set instanceof SortedSet) {
|
|
return asMap((SortedSet<K>) set, function);
|
|
} else {
|
|
return new AsMapView<K, V>(set, function);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a view of the sorted set as a map, mapping keys from the set
|
|
* according to the specified function.
|
|
*
|
|
* <p>
|
|
* Specifically, for each {@code k} in the backing set, the returned map has an
|
|
* entry mapping {@code k} to {@code function.apply(k)}. The {@code
|
|
* keySet}, {@code values}, and {@code entrySet} views of the returned map
|
|
* iterate in the same order as the backing set.
|
|
*
|
|
* <p>
|
|
* Modifications to the backing set are read through to the returned map. The
|
|
* returned map supports removal operations if the backing set does. Removal
|
|
* operations write through to the backing set. The returned map does not
|
|
* support put operations.
|
|
*
|
|
* <p>
|
|
* <b>Warning</b>: If the function rejects {@code null}, caution is required to
|
|
* make sure the set does not contain {@code null}, because the view cannot stop
|
|
* {@code null} from being added to the set.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> This method assumes that for any instance {@code k} of key
|
|
* type {@code K}, {@code k.equals(k2)} implies that {@code k2} is also of type
|
|
* {@code K}. Using a key type for which this may not hold, such as
|
|
* {@code ArrayList}, may risk a {@code ClassCastException} when calling methods
|
|
* on the resulting map view.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
@Beta
|
|
public static <K, V> SortedMap<K, V> asMap(SortedSet<K> set, Function<? super K, V> function) {
|
|
return Platform.mapsAsMapSortedSet(set, function);
|
|
}
|
|
|
|
static <K, V> SortedMap<K, V> asMapSortedIgnoreNavigable(SortedSet<K> set, Function<? super K, V> function) {
|
|
return new SortedAsMapView<K, V>(set, function);
|
|
}
|
|
|
|
/**
|
|
* Returns a view of the navigable set as a map, mapping keys from the set
|
|
* according to the specified function.
|
|
*
|
|
* <p>
|
|
* Specifically, for each {@code k} in the backing set, the returned map has an
|
|
* entry mapping {@code k} to {@code function.apply(k)}. The {@code
|
|
* keySet}, {@code values}, and {@code entrySet} views of the returned map
|
|
* iterate in the same order as the backing set.
|
|
*
|
|
* <p>
|
|
* Modifications to the backing set are read through to the returned map. The
|
|
* returned map supports removal operations if the backing set does. Removal
|
|
* operations write through to the backing set. The returned map does not
|
|
* support put operations.
|
|
*
|
|
* <p>
|
|
* <b>Warning</b>: If the function rejects {@code null}, caution is required to
|
|
* make sure the set does not contain {@code null}, because the view cannot stop
|
|
* {@code null} from being added to the set.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> This method assumes that for any instance {@code k} of key
|
|
* type {@code K}, {@code k.equals(k2)} implies that {@code k2} is also of type
|
|
* {@code K}. Using a key type for which this may not hold, such as
|
|
* {@code ArrayList}, may risk a {@code ClassCastException} when calling methods
|
|
* on the resulting map view.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
@Beta
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V> NavigableMap<K, V> asMap(NavigableSet<K> set, Function<? super K, V> function) {
|
|
return new NavigableAsMapView<K, V>(set, function);
|
|
}
|
|
|
|
private static class AsMapView<K, V> extends ImprovedAbstractMap<K, V> {
|
|
|
|
private final Set<K> set;
|
|
final Function<? super K, V> function;
|
|
|
|
Set<K> backingSet() {
|
|
return set;
|
|
}
|
|
|
|
AsMapView(Set<K> set, Function<? super K, V> function) {
|
|
this.set = checkNotNull(set);
|
|
this.function = checkNotNull(function);
|
|
}
|
|
|
|
@Override
|
|
public Set<K> createKeySet() {
|
|
return removeOnlySet(backingSet());
|
|
}
|
|
|
|
@Override
|
|
Collection<V> createValues() {
|
|
return Collections2.transform(set, function);
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return backingSet().size();
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey(@Nullable Object key) {
|
|
return backingSet().contains(key);
|
|
}
|
|
|
|
@Override
|
|
public V get(@Nullable Object key) {
|
|
if (Collections2.safeContains(backingSet(), key)) {
|
|
@SuppressWarnings("unchecked") // unsafe, but Javadoc warns about it
|
|
K k = (K) key;
|
|
return function.apply(k);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public V remove(@Nullable Object key) {
|
|
if (backingSet().remove(key)) {
|
|
@SuppressWarnings("unchecked") // unsafe, but Javadoc warns about it
|
|
K k = (K) key;
|
|
return function.apply(k);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
backingSet().clear();
|
|
}
|
|
|
|
@Override
|
|
protected Set<Entry<K, V>> createEntrySet() {
|
|
return new EntrySet<K, V>() {
|
|
@Override
|
|
Map<K, V> map() {
|
|
return AsMapView.this;
|
|
}
|
|
|
|
@Override
|
|
public Iterator<Entry<K, V>> iterator() {
|
|
return asMapEntryIterator(backingSet(), function);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
static <K, V> Iterator<Entry<K, V>> asMapEntryIterator(Set<K> set, final Function<? super K, V> function) {
|
|
return new TransformedIterator<K, Entry<K, V>>(set.iterator()) {
|
|
@Override
|
|
Entry<K, V> transform(final K key) {
|
|
return immutableEntry(key, function.apply(key));
|
|
}
|
|
};
|
|
}
|
|
|
|
private static class SortedAsMapView<K, V> extends AsMapView<K, V> implements SortedMap<K, V> {
|
|
|
|
SortedAsMapView(SortedSet<K> set, Function<? super K, V> function) {
|
|
super(set, function);
|
|
}
|
|
|
|
@Override
|
|
SortedSet<K> backingSet() {
|
|
return (SortedSet<K>) super.backingSet();
|
|
}
|
|
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
return backingSet().comparator();
|
|
}
|
|
|
|
@Override
|
|
public Set<K> keySet() {
|
|
return removeOnlySortedSet(backingSet());
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> subMap(K fromKey, K toKey) {
|
|
return asMap(backingSet().subSet(fromKey, toKey), function);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> headMap(K toKey) {
|
|
return asMap(backingSet().headSet(toKey), function);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> tailMap(K fromKey) {
|
|
return asMap(backingSet().tailSet(fromKey), function);
|
|
}
|
|
|
|
@Override
|
|
public K firstKey() {
|
|
return backingSet().first();
|
|
}
|
|
|
|
@Override
|
|
public K lastKey() {
|
|
return backingSet().last();
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible("NavigableMap")
|
|
private static final class NavigableAsMapView<K, V> extends AbstractNavigableMap<K, V> {
|
|
/*
|
|
* Using AbstractNavigableMap is simpler than extending SortedAsMapView and
|
|
* rewriting all the NavigableMap methods.
|
|
*/
|
|
|
|
private final NavigableSet<K> set;
|
|
private final Function<? super K, V> function;
|
|
|
|
NavigableAsMapView(NavigableSet<K> ks, Function<? super K, V> vFunction) {
|
|
this.set = checkNotNull(ks);
|
|
this.function = checkNotNull(vFunction);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
|
|
return asMap(set.subSet(fromKey, fromInclusive, toKey, toInclusive), function);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
|
|
return asMap(set.headSet(toKey, inclusive), function);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
|
|
return asMap(set.tailSet(fromKey, inclusive), function);
|
|
}
|
|
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
return set.comparator();
|
|
}
|
|
|
|
@Override
|
|
@Nullable
|
|
public V get(@Nullable Object key) {
|
|
if (Collections2.safeContains(set, key)) {
|
|
@SuppressWarnings("unchecked") // unsafe, but Javadoc warns about it
|
|
K k = (K) key;
|
|
return function.apply(k);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
set.clear();
|
|
}
|
|
|
|
@Override
|
|
Iterator<Entry<K, V>> entryIterator() {
|
|
return asMapEntryIterator(set, function);
|
|
}
|
|
|
|
@Override
|
|
Iterator<Entry<K, V>> descendingEntryIterator() {
|
|
return descendingMap().entrySet().iterator();
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> navigableKeySet() {
|
|
return removeOnlyNavigableSet(set);
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return set.size();
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> descendingMap() {
|
|
return asMap(set.descendingSet(), function);
|
|
}
|
|
}
|
|
|
|
private static <E> Set<E> removeOnlySet(final Set<E> set) {
|
|
return new ForwardingSet<E>() {
|
|
@Override
|
|
protected Set<E> delegate() {
|
|
return set;
|
|
}
|
|
|
|
@Override
|
|
public boolean add(E element) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public boolean addAll(Collection<? extends E> es) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
};
|
|
}
|
|
|
|
private static <E> SortedSet<E> removeOnlySortedSet(final SortedSet<E> set) {
|
|
return new ForwardingSortedSet<E>() {
|
|
@Override
|
|
protected SortedSet<E> delegate() {
|
|
return set;
|
|
}
|
|
|
|
@Override
|
|
public boolean add(E element) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public boolean addAll(Collection<? extends E> es) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<E> headSet(E toElement) {
|
|
return removeOnlySortedSet(super.headSet(toElement));
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<E> subSet(E fromElement, E toElement) {
|
|
return removeOnlySortedSet(super.subSet(fromElement, toElement));
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<E> tailSet(E fromElement) {
|
|
return removeOnlySortedSet(super.tailSet(fromElement));
|
|
}
|
|
};
|
|
}
|
|
|
|
@GwtIncompatible("NavigableSet")
|
|
private static <E> NavigableSet<E> removeOnlyNavigableSet(final NavigableSet<E> set) {
|
|
return new ForwardingNavigableSet<E>() {
|
|
@Override
|
|
protected NavigableSet<E> delegate() {
|
|
return set;
|
|
}
|
|
|
|
@Override
|
|
public boolean add(E element) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public boolean addAll(Collection<? extends E> es) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<E> headSet(E toElement) {
|
|
return removeOnlySortedSet(super.headSet(toElement));
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<E> subSet(E fromElement, E toElement) {
|
|
return removeOnlySortedSet(super.subSet(fromElement, toElement));
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<E> tailSet(E fromElement) {
|
|
return removeOnlySortedSet(super.tailSet(fromElement));
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
|
|
return removeOnlyNavigableSet(super.headSet(toElement, inclusive));
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
|
|
return removeOnlyNavigableSet(super.tailSet(fromElement, inclusive));
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
|
|
return removeOnlyNavigableSet(super.subSet(fromElement, fromInclusive, toElement, toInclusive));
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<E> descendingSet() {
|
|
return removeOnlyNavigableSet(super.descendingSet());
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns an immutable map whose keys are the distinct elements of {@code
|
|
* keys} and whose value for each key was computed by {@code valueFunction}. The
|
|
* map's iteration order is the order of the first appearance of each key in
|
|
* {@code keys}.
|
|
*
|
|
* <p>
|
|
* If {@code keys} is a {@link Set}, a live view can be obtained instead of a
|
|
* copy using {@link Maps#asMap(Set, Function)}.
|
|
*
|
|
* @throws NullPointerException if any element of {@code keys} is {@code null},
|
|
* or if {@code valueFunction} produces
|
|
* {@code null} for any key
|
|
* @since 14.0
|
|
*/
|
|
@Beta
|
|
public static <K, V> ImmutableMap<K, V> toMap(Iterable<K> keys, Function<? super K, V> valueFunction) {
|
|
return toMap(keys.iterator(), valueFunction);
|
|
}
|
|
|
|
/**
|
|
* Returns an immutable map whose keys are the distinct elements of {@code
|
|
* keys} and whose value for each key was computed by {@code valueFunction}. The
|
|
* map's iteration order is the order of the first appearance of each key in
|
|
* {@code keys}.
|
|
*
|
|
* @throws NullPointerException if any element of {@code keys} is {@code null},
|
|
* or if {@code valueFunction} produces
|
|
* {@code null} for any key
|
|
* @since 14.0
|
|
*/
|
|
@Beta
|
|
public static <K, V> ImmutableMap<K, V> toMap(Iterator<K> keys, Function<? super K, V> valueFunction) {
|
|
checkNotNull(valueFunction);
|
|
// Using LHM instead of a builder so as not to fail on duplicate keys
|
|
Map<K, V> builder = newLinkedHashMap();
|
|
while (keys.hasNext()) {
|
|
K key = keys.next();
|
|
builder.put(key, valueFunction.apply(key));
|
|
}
|
|
return ImmutableMap.copyOf(builder);
|
|
}
|
|
|
|
/**
|
|
* Returns an immutable map for which the {@link Map#values} are the given
|
|
* elements in the given order, and each key is the product of invoking a
|
|
* supplied function on its corresponding value.
|
|
*
|
|
* @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} is null,
|
|
* or if {@code keyFunction} produces
|
|
* {@code null} for any value
|
|
*/
|
|
public static <K, V> ImmutableMap<K, V> uniqueIndex(Iterable<V> values, Function<? super V, K> keyFunction) {
|
|
return uniqueIndex(values.iterator(), keyFunction);
|
|
}
|
|
|
|
/**
|
|
* Returns an immutable map for which the {@link Map#values} are the given
|
|
* elements in the given order, and each key is the product of invoking a
|
|
* supplied function on its corresponding value.
|
|
*
|
|
* @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} is null,
|
|
* or if {@code keyFunction} produces
|
|
* {@code null} for any value
|
|
* @since 10.0
|
|
*/
|
|
public static <K, V> ImmutableMap<K, V> uniqueIndex(Iterator<V> values, Function<? super V, K> keyFunction) {
|
|
checkNotNull(keyFunction);
|
|
ImmutableMap.Builder<K, V> builder = ImmutableMap.builder();
|
|
while (values.hasNext()) {
|
|
V value = values.next();
|
|
builder.put(keyFunction.apply(value), value);
|
|
}
|
|
return 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();
|
|
}
|
|
|
|
/**
|
|
* Returns an immutable map entry with the specified key and value. The
|
|
* {@link Entry#setValue} operation throws an
|
|
* {@link UnsupportedOperationException}.
|
|
*
|
|
* <p>
|
|
* 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
|
|
*/
|
|
@GwtCompatible(serializable = true)
|
|
public static <K, V> Entry<K, V> immutableEntry(@Nullable K key, @Nullable V value) {
|
|
return new ImmutableEntry<K, V>(key, value);
|
|
}
|
|
|
|
/**
|
|
* 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 <K, V> Set<Entry<K, V>> unmodifiableEntrySet(Set<Entry<K, V>> entrySet) {
|
|
return new UnmodifiableEntrySet<K, V>(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
|
|
*/
|
|
static <K, V> Entry<K, V> unmodifiableEntry(final Entry<? extends K, ? extends V> entry) {
|
|
checkNotNull(entry);
|
|
return new AbstractMapEntry<K, V>() {
|
|
@Override
|
|
public K getKey() {
|
|
return entry.getKey();
|
|
}
|
|
|
|
@Override
|
|
public V getValue() {
|
|
return entry.getValue();
|
|
}
|
|
};
|
|
}
|
|
|
|
/** @see Multimaps#unmodifiableEntries */
|
|
static class UnmodifiableEntries<K, V> extends ForwardingCollection<Entry<K, V>> {
|
|
private final Collection<Entry<K, V>> entries;
|
|
|
|
UnmodifiableEntries(Collection<Entry<K, V>> entries) {
|
|
this.entries = entries;
|
|
}
|
|
|
|
@Override
|
|
protected Collection<Entry<K, V>> delegate() {
|
|
return entries;
|
|
}
|
|
|
|
@Override
|
|
public Iterator<Entry<K, V>> iterator() {
|
|
final Iterator<Entry<K, V>> delegate = super.iterator();
|
|
return new UnmodifiableIterator<Entry<K, V>>() {
|
|
@Override
|
|
public boolean hasNext() {
|
|
return delegate.hasNext();
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> next() {
|
|
return unmodifiableEntry(delegate.next());
|
|
}
|
|
};
|
|
}
|
|
|
|
// See java.util.Collections.UnmodifiableEntrySet for details on attacks.
|
|
|
|
@Override
|
|
public Object[] toArray() {
|
|
return standardToArray();
|
|
}
|
|
|
|
@Override
|
|
public <T> T[] toArray(T[] array) {
|
|
return standardToArray(array);
|
|
}
|
|
}
|
|
|
|
/** @see Maps#unmodifiableEntrySet(Set) */
|
|
static class UnmodifiableEntrySet<K, V> extends UnmodifiableEntries<K, V> implements Set<Entry<K, V>> {
|
|
UnmodifiableEntrySet(Set<Entry<K, V>> entries) {
|
|
super(entries);
|
|
}
|
|
|
|
// See java.util.Collections.UnmodifiableEntrySet for details on attacks.
|
|
|
|
@Override
|
|
public boolean equals(@Nullable Object object) {
|
|
return Sets.equalsImpl(this, object);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Sets.hashCodeImpl(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link Converter} that converts values using {@link BiMap#get
|
|
* bimap.get()}, and whose inverse view converts values using
|
|
* {@link BiMap#inverse bimap.inverse()}{@code .get()}.
|
|
*
|
|
* <p>
|
|
* To use a plain {@link Map} as a {@link Function}, see
|
|
* {@link com.google.common.base.Functions#forMap(Map)} or
|
|
* {@link com.google.common.base.Functions#forMap(Map, Object)}.
|
|
*
|
|
* @since 16.0
|
|
*/
|
|
@Beta
|
|
public static <A, B> Converter<A, B> asConverter(final BiMap<A, B> bimap) {
|
|
return new BiMapConverter<A, B>(bimap);
|
|
}
|
|
|
|
private static final class BiMapConverter<A, B> extends Converter<A, B> implements Serializable {
|
|
private final BiMap<A, B> bimap;
|
|
|
|
BiMapConverter(BiMap<A, B> bimap) {
|
|
this.bimap = checkNotNull(bimap);
|
|
}
|
|
|
|
@Override
|
|
protected B doForward(A a) {
|
|
return convert(bimap, a);
|
|
}
|
|
|
|
@Override
|
|
protected A doBackward(B b) {
|
|
return convert(bimap.inverse(), b);
|
|
}
|
|
|
|
private static <X, Y> Y convert(BiMap<X, Y> bimap, X input) {
|
|
Y output = bimap.get(input);
|
|
checkArgument(output != null, "No non-null mapping present for input: %s", input);
|
|
return output;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(@Nullable Object object) {
|
|
if (object instanceof BiMapConverter) {
|
|
BiMapConverter<?, ?> that = (BiMapConverter<?, ?>) object;
|
|
return this.bimap.equals(that.bimap);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return bimap.hashCode();
|
|
}
|
|
|
|
// There's really no good way to implement toString() without printing the
|
|
// entire BiMap, right?
|
|
@Override
|
|
public String toString() {
|
|
return "Maps.asConverter(" + bimap + ")";
|
|
}
|
|
|
|
private static final long serialVersionUID = 0L;
|
|
}
|
|
|
|
/**
|
|
* Returns a synchronized (thread-safe) bimap backed by the specified bimap. In
|
|
* order to guarantee serial access, it is critical that <b>all</b> access to
|
|
* the backing bimap is accomplished through the returned bimap.
|
|
*
|
|
* <p>
|
|
* It is imperative that the user manually synchronize on the returned map when
|
|
* accessing any of its collection views:
|
|
*
|
|
* <pre>
|
|
* {@code
|
|
*
|
|
* BiMap<Long, String> map = Maps.synchronizedBiMap(
|
|
* HashBiMap.<Long, String>create());
|
|
* ...
|
|
* Set<Long> set = map.keySet(); // Needn't be in synchronized block
|
|
* ...
|
|
* synchronized (map) { // Synchronizing on map, not set!
|
|
* Iterator<Long> it = set.iterator(); // Must be in synchronized block
|
|
* while (it.hasNext()) {
|
|
* foo(it.next());
|
|
* }
|
|
* }}
|
|
* </pre>
|
|
*
|
|
* <p>
|
|
* Failure to follow this advice may result in non-deterministic behavior.
|
|
*
|
|
* <p>
|
|
* The returned bimap will be serializable if the specified bimap is
|
|
* serializable.
|
|
*
|
|
* @param bimap the bimap to be wrapped in a synchronized view
|
|
* @return a sychronized view of the specified bimap
|
|
*/
|
|
public static <K, V> BiMap<K, V> synchronizedBiMap(BiMap<K, V> bimap) {
|
|
return Synchronized.biMap(bimap, null);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* attempts to modify the returned map, whether direct or via its collection
|
|
* views, result in an {@code UnsupportedOperationException}.
|
|
*
|
|
* <p>
|
|
* The returned bimap will be serializable if the specified bimap 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 <K, V> BiMap<K, V> unmodifiableBiMap(BiMap<? extends K, ? extends V> bimap) {
|
|
return new UnmodifiableBiMap<K, V>(bimap, null);
|
|
}
|
|
|
|
/** @see Maps#unmodifiableBiMap(BiMap) */
|
|
private static class UnmodifiableBiMap<K, V> extends ForwardingMap<K, V> implements BiMap<K, V>, Serializable {
|
|
final Map<K, V> unmodifiableMap;
|
|
final BiMap<? extends K, ? extends V> delegate;
|
|
BiMap<V, K> inverse;
|
|
transient Set<V> values;
|
|
|
|
UnmodifiableBiMap(BiMap<? extends K, ? extends V> delegate, @Nullable BiMap<V, K> inverse) {
|
|
unmodifiableMap = Collections.unmodifiableMap(delegate);
|
|
this.delegate = delegate;
|
|
this.inverse = inverse;
|
|
}
|
|
|
|
@Override
|
|
protected Map<K, V> delegate() {
|
|
return unmodifiableMap;
|
|
}
|
|
|
|
@Override
|
|
public V forcePut(K key, V value) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public BiMap<V, K> inverse() {
|
|
BiMap<V, K> result = inverse;
|
|
return (result == null) ? inverse = new UnmodifiableBiMap<V, K>(delegate.inverse(), this) : result;
|
|
}
|
|
|
|
@Override
|
|
public Set<V> values() {
|
|
Set<V> result = values;
|
|
return (result == null) ? values = Collections.unmodifiableSet(delegate.values()) : result;
|
|
}
|
|
|
|
private static final long serialVersionUID = 0;
|
|
}
|
|
|
|
/**
|
|
* Returns a view of a map where each value is transformed by a function. All
|
|
* other properties of the map, such as iteration order, are left intact. For
|
|
* example, the code:
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* Map<String, Integer> map = ImmutableMap.of("a", 4, "b", 9);
|
|
* Function<Integer, Double> sqrt = new Function<Integer, Double>() {
|
|
* public Double apply(Integer in) {
|
|
* return Math.sqrt((int) in);
|
|
* }
|
|
* };
|
|
* Map<String, Double> transformed = Maps.transformValues(map, sqrt);
|
|
* System.out.println(transformed);
|
|
* }
|
|
* </pre>
|
|
*
|
|
* ... prints {@code {a=2.0, b=3.0}}.
|
|
*
|
|
* <p>
|
|
* Changes in the underlying map are reflected in this view. Conversely, this
|
|
* view supports removal operations, and these are reflected in the underlying
|
|
* map.
|
|
*
|
|
* <p>
|
|
* It's acceptable for the underlying map to contain null keys, and even null
|
|
* values provided that the function is capable of accepting null input. The
|
|
* transformed map might contain null values, if the function sometimes gives a
|
|
* null result.
|
|
*
|
|
* <p>
|
|
* The returned map is not thread-safe or serializable, even if the underlying
|
|
* map is.
|
|
*
|
|
* <p>
|
|
* The function is applied lazily, invoked when needed. This is necessary for
|
|
* the returned map to be a view, but it means that the function will be applied
|
|
* many times for bulk operations like {@link Map#containsValue} and
|
|
* {@code Map.toString()}. For this to perform well, {@code function} should be
|
|
* fast. To avoid lazy evaluation when the returned map doesn't need to be a
|
|
* view, copy the returned map into a new map of your choosing.
|
|
*/
|
|
public static <K, V1, V2> Map<K, V2> transformValues(Map<K, V1> fromMap, Function<? super V1, V2> function) {
|
|
return transformEntries(fromMap, asEntryTransformer(function));
|
|
}
|
|
|
|
/**
|
|
* Returns a view of a sorted map where each value is transformed by a function.
|
|
* All other properties of the map, such as iteration order, are left intact.
|
|
* For example, the code:
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* SortedMap<String, Integer> map = ImmutableSortedMap.of("a", 4, "b", 9);
|
|
* Function<Integer, Double> sqrt = new Function<Integer, Double>() {
|
|
* public Double apply(Integer in) {
|
|
* return Math.sqrt((int) in);
|
|
* }
|
|
* };
|
|
* SortedMap<String, Double> transformed = Maps.transformValues(map, sqrt);
|
|
* System.out.println(transformed);
|
|
* }
|
|
* </pre>
|
|
*
|
|
* ... prints {@code {a=2.0, b=3.0}}.
|
|
*
|
|
* <p>
|
|
* Changes in the underlying map are reflected in this view. Conversely, this
|
|
* view supports removal operations, and these are reflected in the underlying
|
|
* map.
|
|
*
|
|
* <p>
|
|
* It's acceptable for the underlying map to contain null keys, and even null
|
|
* values provided that the function is capable of accepting null input. The
|
|
* transformed map might contain null values, if the function sometimes gives a
|
|
* null result.
|
|
*
|
|
* <p>
|
|
* The returned map is not thread-safe or serializable, even if the underlying
|
|
* map is.
|
|
*
|
|
* <p>
|
|
* The function is applied lazily, invoked when needed. This is necessary for
|
|
* the returned map to be a view, but it means that the function will be applied
|
|
* many times for bulk operations like {@link Map#containsValue} and
|
|
* {@code Map.toString()}. For this to perform well, {@code function} should be
|
|
* fast. To avoid lazy evaluation when the returned map doesn't need to be a
|
|
* view, copy the returned map into a new map of your choosing.
|
|
*
|
|
* @since 11.0
|
|
*/
|
|
public static <K, V1, V2> SortedMap<K, V2> transformValues(SortedMap<K, V1> fromMap,
|
|
Function<? super V1, V2> function) {
|
|
return transformEntries(fromMap, asEntryTransformer(function));
|
|
}
|
|
|
|
/**
|
|
* Returns a view of a navigable map where each value is transformed by a
|
|
* function. All other properties of the map, such as iteration order, are left
|
|
* intact. For example, the code:
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* NavigableMap<String, Integer> map = Maps.newTreeMap();
|
|
* map.put("a", 4);
|
|
* map.put("b", 9);
|
|
* Function<Integer, Double> sqrt = new Function<Integer, Double>() {
|
|
* public Double apply(Integer in) {
|
|
* return Math.sqrt((int) in);
|
|
* }
|
|
* };
|
|
* NavigableMap<String, Double> transformed = Maps.transformNavigableValues(map, sqrt);
|
|
* System.out.println(transformed);
|
|
* }
|
|
* </pre>
|
|
*
|
|
* ... prints {@code {a=2.0, b=3.0}}.
|
|
*
|
|
* Changes in the underlying map are reflected in this view. Conversely, this
|
|
* view supports removal operations, and these are reflected in the underlying
|
|
* map.
|
|
*
|
|
* <p>
|
|
* It's acceptable for the underlying map to contain null keys, and even null
|
|
* values provided that the function is capable of accepting null input. The
|
|
* transformed map might contain null values, if the function sometimes gives a
|
|
* null result.
|
|
*
|
|
* <p>
|
|
* The returned map is not thread-safe or serializable, even if the underlying
|
|
* map is.
|
|
*
|
|
* <p>
|
|
* The function is applied lazily, invoked when needed. This is necessary for
|
|
* the returned map to be a view, but it means that the function will be applied
|
|
* many times for bulk operations like {@link Map#containsValue} and
|
|
* {@code Map.toString()}. For this to perform well, {@code function} should be
|
|
* fast. To avoid lazy evaluation when the returned map doesn't need to be a
|
|
* view, copy the returned map into a new map of your choosing.
|
|
*
|
|
* @since 13.0
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V1, V2> NavigableMap<K, V2> transformValues(NavigableMap<K, V1> fromMap,
|
|
Function<? super V1, V2> function) {
|
|
return transformEntries(fromMap, asEntryTransformer(function));
|
|
}
|
|
|
|
/**
|
|
* Returns a view of a map whose values are derived from the original map's
|
|
* entries. In contrast to {@link #transformValues}, this method's
|
|
* entry-transformation logic may depend on the key as well as the value.
|
|
*
|
|
* <p>
|
|
* All other properties of the transformed map, such as iteration order, are
|
|
* left intact. For example, the code:
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* Map<String, Boolean> options = ImmutableMap.of("verbose", true, "sort", false);
|
|
* EntryTransformer<String, Boolean, String> flagPrefixer = new EntryTransformer<String, Boolean, String>() {
|
|
* public String transformEntry(String key, Boolean value) {
|
|
* return value ? key : "no" + key;
|
|
* }
|
|
* };
|
|
* Map<String, String> transformed = Maps.transformEntries(options, flagPrefixer);
|
|
* System.out.println(transformed);
|
|
* }
|
|
* </pre>
|
|
*
|
|
* ... prints {@code {verbose=verbose, sort=nosort}}.
|
|
*
|
|
* <p>
|
|
* Changes in the underlying map are reflected in this view. Conversely, this
|
|
* view supports removal operations, and these are reflected in the underlying
|
|
* map.
|
|
*
|
|
* <p>
|
|
* It's acceptable for the underlying map to contain null keys and null values
|
|
* provided that the transformer is capable of accepting null inputs. The
|
|
* transformed map might contain null values if the transformer sometimes gives
|
|
* a null result.
|
|
*
|
|
* <p>
|
|
* The returned map is not thread-safe or serializable, even if the underlying
|
|
* map is.
|
|
*
|
|
* <p>
|
|
* The transformer is applied lazily, invoked when needed. This is necessary for
|
|
* the returned map to be a view, but it means that the transformer will be
|
|
* applied many times for bulk operations like {@link Map#containsValue} and
|
|
* {@link Object#toString}. For this to perform well, {@code transformer} should
|
|
* be fast. To avoid lazy evaluation when the returned map doesn't need to be a
|
|
* view, copy the returned map into a new map of your choosing.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> This method assumes that for any instance {@code k} of
|
|
* {@code EntryTransformer} key type {@code K}, {@code k.equals(k2)} implies
|
|
* that {@code k2} is also of type {@code K}. Using an {@code
|
|
* EntryTransformer} key type for which this may not hold, such as {@code
|
|
* ArrayList}, may risk a {@code ClassCastException} when calling methods on the
|
|
* transformed map.
|
|
*
|
|
* @since 7.0
|
|
*/
|
|
public static <K, V1, V2> Map<K, V2> transformEntries(Map<K, V1> fromMap,
|
|
EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
if (fromMap instanceof SortedMap) {
|
|
return transformEntries((SortedMap<K, V1>) fromMap, transformer);
|
|
}
|
|
return new TransformedEntriesMap<K, V1, V2>(fromMap, transformer);
|
|
}
|
|
|
|
/**
|
|
* Returns a view of a sorted map whose values are derived from the original
|
|
* sorted map's entries. In contrast to {@link #transformValues}, this method's
|
|
* entry-transformation logic may depend on the key as well as the value.
|
|
*
|
|
* <p>
|
|
* All other properties of the transformed map, such as iteration order, are
|
|
* left intact. For example, the code:
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* Map<String, Boolean> options = ImmutableSortedMap.of("verbose", true, "sort", false);
|
|
* EntryTransformer<String, Boolean, String> flagPrefixer = new EntryTransformer<String, Boolean, String>() {
|
|
* public String transformEntry(String key, Boolean value) {
|
|
* return value ? key : "yes" + key;
|
|
* }
|
|
* };
|
|
* SortedMap<String, String> transformed = Maps.transformEntries(options, flagPrefixer);
|
|
* System.out.println(transformed);
|
|
* }
|
|
* </pre>
|
|
*
|
|
* ... prints {@code {sort=yessort, verbose=verbose}}.
|
|
*
|
|
* <p>
|
|
* Changes in the underlying map are reflected in this view. Conversely, this
|
|
* view supports removal operations, and these are reflected in the underlying
|
|
* map.
|
|
*
|
|
* <p>
|
|
* It's acceptable for the underlying map to contain null keys and null values
|
|
* provided that the transformer is capable of accepting null inputs. The
|
|
* transformed map might contain null values if the transformer sometimes gives
|
|
* a null result.
|
|
*
|
|
* <p>
|
|
* The returned map is not thread-safe or serializable, even if the underlying
|
|
* map is.
|
|
*
|
|
* <p>
|
|
* The transformer is applied lazily, invoked when needed. This is necessary for
|
|
* the returned map to be a view, but it means that the transformer will be
|
|
* applied many times for bulk operations like {@link Map#containsValue} and
|
|
* {@link Object#toString}. For this to perform well, {@code transformer} should
|
|
* be fast. To avoid lazy evaluation when the returned map doesn't need to be a
|
|
* view, copy the returned map into a new map of your choosing.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> This method assumes that for any instance {@code k} of
|
|
* {@code EntryTransformer} key type {@code K}, {@code k.equals(k2)} implies
|
|
* that {@code k2} is also of type {@code K}. Using an {@code
|
|
* EntryTransformer} key type for which this may not hold, such as {@code
|
|
* ArrayList}, may risk a {@code ClassCastException} when calling methods on the
|
|
* transformed map.
|
|
*
|
|
* @since 11.0
|
|
*/
|
|
public static <K, V1, V2> SortedMap<K, V2> transformEntries(SortedMap<K, V1> fromMap,
|
|
EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
return Platform.mapsTransformEntriesSortedMap(fromMap, transformer);
|
|
}
|
|
|
|
/**
|
|
* Returns a view of a navigable map whose values are derived from the original
|
|
* navigable map's entries. In contrast to {@link #transformValues}, this
|
|
* method's entry-transformation logic may depend on the key as well as the
|
|
* value.
|
|
*
|
|
* <p>
|
|
* All other properties of the transformed map, such as iteration order, are
|
|
* left intact. For example, the code:
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* NavigableMap<String, Boolean> options = Maps.newTreeMap();
|
|
* options.put("verbose", false);
|
|
* options.put("sort", true);
|
|
* EntryTransformer<String, Boolean, String> flagPrefixer = new EntryTransformer<String, Boolean, String>() {
|
|
* public String transformEntry(String key, Boolean value) {
|
|
* return value ? key : ("yes" + key);
|
|
* }
|
|
* };
|
|
* NavigableMap<String, String> transformed = LabsMaps.transformNavigableEntries(options, flagPrefixer);
|
|
* System.out.println(transformed);
|
|
* }
|
|
* </pre>
|
|
*
|
|
* ... prints {@code {sort=yessort, verbose=verbose}}.
|
|
*
|
|
* <p>
|
|
* Changes in the underlying map are reflected in this view. Conversely, this
|
|
* view supports removal operations, and these are reflected in the underlying
|
|
* map.
|
|
*
|
|
* <p>
|
|
* It's acceptable for the underlying map to contain null keys and null values
|
|
* provided that the transformer is capable of accepting null inputs. The
|
|
* transformed map might contain null values if the transformer sometimes gives
|
|
* a null result.
|
|
*
|
|
* <p>
|
|
* The returned map is not thread-safe or serializable, even if the underlying
|
|
* map is.
|
|
*
|
|
* <p>
|
|
* The transformer is applied lazily, invoked when needed. This is necessary for
|
|
* the returned map to be a view, but it means that the transformer will be
|
|
* applied many times for bulk operations like {@link Map#containsValue} and
|
|
* {@link Object#toString}. For this to perform well, {@code transformer} should
|
|
* be fast. To avoid lazy evaluation when the returned map doesn't need to be a
|
|
* view, copy the returned map into a new map of your choosing.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> This method assumes that for any instance {@code k} of
|
|
* {@code EntryTransformer} key type {@code K}, {@code k.equals(k2)} implies
|
|
* that {@code k2} is also of type {@code K}. Using an {@code
|
|
* EntryTransformer} key type for which this may not hold, such as {@code
|
|
* ArrayList}, may risk a {@code ClassCastException} when calling methods on the
|
|
* transformed map.
|
|
*
|
|
* @since 13.0
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V1, V2> NavigableMap<K, V2> transformEntries(final NavigableMap<K, V1> fromMap,
|
|
EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
return new TransformedEntriesNavigableMap<K, V1, V2>(fromMap, transformer);
|
|
}
|
|
|
|
static <K, V1, V2> SortedMap<K, V2> transformEntriesIgnoreNavigable(SortedMap<K, V1> fromMap,
|
|
EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
return new TransformedEntriesSortedMap<K, V1, V2>(fromMap, transformer);
|
|
}
|
|
|
|
/**
|
|
* A transformation of the value of a key-value pair, using both key and value
|
|
* as inputs. To apply the transformation to a map, use
|
|
* {@link Maps#transformEntries(Map, EntryTransformer)}.
|
|
*
|
|
* @param <K> the key type of the input and output entries
|
|
* @param <V1> the value type of the input entry
|
|
* @param <V2> the value type of the output entry
|
|
* @since 7.0
|
|
*/
|
|
public interface EntryTransformer<K, V1, V2> {
|
|
/**
|
|
* Determines an output value based on a key-value pair. This method is
|
|
* <i>generally expected</i>, but not absolutely required, to have the following
|
|
* properties:
|
|
*
|
|
* <ul>
|
|
* <li>Its execution does not cause any observable side effects.
|
|
* <li>The computation is <i>consistent with equals</i>; that is,
|
|
* {@link Objects#equal Objects.equal}{@code (k1, k2) &&}
|
|
* {@link Objects#equal}{@code (v1, v2)} implies that {@code
|
|
* Objects.equal(transformer.transform(k1, v1),
|
|
* transformer.transform(k2, v2))}.
|
|
* </ul>
|
|
*
|
|
* @throws NullPointerException if the key or value is null and this transformer
|
|
* does not accept null arguments
|
|
*/
|
|
V2 transformEntry(@Nullable K key, @Nullable V1 value);
|
|
}
|
|
|
|
/**
|
|
* Views a function as an entry transformer that ignores the entry key.
|
|
*/
|
|
static <K, V1, V2> EntryTransformer<K, V1, V2> asEntryTransformer(final Function<? super V1, V2> function) {
|
|
checkNotNull(function);
|
|
return new EntryTransformer<K, V1, V2>() {
|
|
@Override
|
|
public V2 transformEntry(K key, V1 value) {
|
|
return function.apply(value);
|
|
}
|
|
};
|
|
}
|
|
|
|
static <K, V1, V2> Function<V1, V2> asValueToValueFunction(final EntryTransformer<? super K, V1, V2> transformer,
|
|
final K key) {
|
|
checkNotNull(transformer);
|
|
return new Function<V1, V2>() {
|
|
@Override
|
|
public V2 apply(@Nullable V1 v1) {
|
|
return transformer.transformEntry(key, v1);
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Views an entry transformer as a function from {@code Entry} to values.
|
|
*/
|
|
static <K, V1, V2> Function<Entry<K, V1>, V2> asEntryToValueFunction(
|
|
final EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
checkNotNull(transformer);
|
|
return new Function<Entry<K, V1>, V2>() {
|
|
@Override
|
|
public V2 apply(Entry<K, V1> entry) {
|
|
return transformer.transformEntry(entry.getKey(), entry.getValue());
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns a view of an entry transformed by the specified transformer.
|
|
*/
|
|
static <V2, K, V1> Entry<K, V2> transformEntry(final EntryTransformer<? super K, ? super V1, V2> transformer,
|
|
final Entry<K, V1> entry) {
|
|
checkNotNull(transformer);
|
|
checkNotNull(entry);
|
|
return new AbstractMapEntry<K, V2>() {
|
|
@Override
|
|
public K getKey() {
|
|
return entry.getKey();
|
|
}
|
|
|
|
@Override
|
|
public V2 getValue() {
|
|
return transformer.transformEntry(entry.getKey(), entry.getValue());
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Views an entry transformer as a function from entries to entries.
|
|
*/
|
|
static <K, V1, V2> Function<Entry<K, V1>, Entry<K, V2>> asEntryToEntryFunction(
|
|
final EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
checkNotNull(transformer);
|
|
return new Function<Entry<K, V1>, Entry<K, V2>>() {
|
|
@Override
|
|
public Entry<K, V2> apply(final Entry<K, V1> entry) {
|
|
return transformEntry(transformer, entry);
|
|
}
|
|
};
|
|
}
|
|
|
|
static class TransformedEntriesMap<K, V1, V2> extends ImprovedAbstractMap<K, V2> {
|
|
final Map<K, V1> fromMap;
|
|
final EntryTransformer<? super K, ? super V1, V2> transformer;
|
|
|
|
TransformedEntriesMap(Map<K, V1> fromMap, EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
this.fromMap = checkNotNull(fromMap);
|
|
this.transformer = checkNotNull(transformer);
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return fromMap.size();
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey(Object key) {
|
|
return fromMap.containsKey(key);
|
|
}
|
|
|
|
// safe as long as the user followed the <b>Warning</b> in the javadoc
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public V2 get(Object key) {
|
|
V1 value = fromMap.get(key);
|
|
return (value != null || fromMap.containsKey(key)) ? transformer.transformEntry((K) key, value) : null;
|
|
}
|
|
|
|
// safe as long as the user followed the <b>Warning</b> in the javadoc
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public V2 remove(Object key) {
|
|
return fromMap.containsKey(key) ? transformer.transformEntry((K) key, fromMap.remove(key)) : null;
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
fromMap.clear();
|
|
}
|
|
|
|
@Override
|
|
public Set<K> keySet() {
|
|
return fromMap.keySet();
|
|
}
|
|
|
|
@Override
|
|
protected Set<Entry<K, V2>> createEntrySet() {
|
|
return new EntrySet<K, V2>() {
|
|
@Override
|
|
Map<K, V2> map() {
|
|
return TransformedEntriesMap.this;
|
|
}
|
|
|
|
@Override
|
|
public Iterator<Entry<K, V2>> iterator() {
|
|
return Iterators.transform(fromMap.entrySet().iterator(),
|
|
Maps.<K, V1, V2>asEntryToEntryFunction(transformer));
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
static class TransformedEntriesSortedMap<K, V1, V2> extends TransformedEntriesMap<K, V1, V2>
|
|
implements SortedMap<K, V2> {
|
|
|
|
protected SortedMap<K, V1> fromMap() {
|
|
return (SortedMap<K, V1>) fromMap;
|
|
}
|
|
|
|
TransformedEntriesSortedMap(SortedMap<K, V1> fromMap, EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
super(fromMap, transformer);
|
|
}
|
|
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
return fromMap().comparator();
|
|
}
|
|
|
|
@Override
|
|
public K firstKey() {
|
|
return fromMap().firstKey();
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V2> headMap(K toKey) {
|
|
return transformEntries(fromMap().headMap(toKey), transformer);
|
|
}
|
|
|
|
@Override
|
|
public K lastKey() {
|
|
return fromMap().lastKey();
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V2> subMap(K fromKey, K toKey) {
|
|
return transformEntries(fromMap().subMap(fromKey, toKey), transformer);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V2> tailMap(K fromKey) {
|
|
return transformEntries(fromMap().tailMap(fromKey), transformer);
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible("NavigableMap")
|
|
private static class TransformedEntriesNavigableMap<K, V1, V2> extends TransformedEntriesSortedMap<K, V1, V2>
|
|
implements NavigableMap<K, V2> {
|
|
|
|
TransformedEntriesNavigableMap(NavigableMap<K, V1> fromMap,
|
|
EntryTransformer<? super K, ? super V1, V2> transformer) {
|
|
super(fromMap, transformer);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> ceilingEntry(K key) {
|
|
return transformEntry(fromMap().ceilingEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K ceilingKey(K key) {
|
|
return fromMap().ceilingKey(key);
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> descendingKeySet() {
|
|
return fromMap().descendingKeySet();
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V2> descendingMap() {
|
|
return transformEntries(fromMap().descendingMap(), transformer);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> firstEntry() {
|
|
return transformEntry(fromMap().firstEntry());
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> floorEntry(K key) {
|
|
return transformEntry(fromMap().floorEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K floorKey(K key) {
|
|
return fromMap().floorKey(key);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V2> headMap(K toKey) {
|
|
return headMap(toKey, false);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V2> headMap(K toKey, boolean inclusive) {
|
|
return transformEntries(fromMap().headMap(toKey, inclusive), transformer);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> higherEntry(K key) {
|
|
return transformEntry(fromMap().higherEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K higherKey(K key) {
|
|
return fromMap().higherKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> lastEntry() {
|
|
return transformEntry(fromMap().lastEntry());
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> lowerEntry(K key) {
|
|
return transformEntry(fromMap().lowerEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K lowerKey(K key) {
|
|
return fromMap().lowerKey(key);
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> navigableKeySet() {
|
|
return fromMap().navigableKeySet();
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> pollFirstEntry() {
|
|
return transformEntry(fromMap().pollFirstEntry());
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V2> pollLastEntry() {
|
|
return transformEntry(fromMap().pollLastEntry());
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V2> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
|
|
return transformEntries(fromMap().subMap(fromKey, fromInclusive, toKey, toInclusive), transformer);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V2> subMap(K fromKey, K toKey) {
|
|
return subMap(fromKey, true, toKey, false);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V2> tailMap(K fromKey) {
|
|
return tailMap(fromKey, true);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V2> tailMap(K fromKey, boolean inclusive) {
|
|
return transformEntries(fromMap().tailMap(fromKey, inclusive), transformer);
|
|
}
|
|
|
|
@Nullable
|
|
private Entry<K, V2> transformEntry(@Nullable Entry<K, V1> entry) {
|
|
return (entry == null) ? null : Maps.transformEntry(transformer, entry);
|
|
}
|
|
|
|
@Override
|
|
protected NavigableMap<K, V1> fromMap() {
|
|
return (NavigableMap<K, V1>) super.fromMap();
|
|
}
|
|
}
|
|
|
|
static <K> Predicate<Entry<K, ?>> keyPredicateOnEntries(Predicate<? super K> keyPredicate) {
|
|
return compose(keyPredicate, Maps.<K>keyFunction());
|
|
}
|
|
|
|
static <V> Predicate<Entry<?, V>> valuePredicateOnEntries(Predicate<? super V> valuePredicate) {
|
|
return compose(valuePredicate, Maps.<V>valueFunction());
|
|
}
|
|
|
|
/**
|
|
* Returns a map containing the mappings in {@code unfiltered} whose keys
|
|
* satisfy a predicate. The returned map is a live view of {@code unfiltered};
|
|
* changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a key that
|
|
* doesn't satisfy the predicate, the map's {@code put()} and {@code putAll()}
|
|
* methods throw an {@link IllegalArgumentException}.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings whose keys satisfy the filter
|
|
* will be removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code keyPredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}. Do not provide a predicate such as
|
|
* {@code Predicates.instanceOf(ArrayList.class)}, which is inconsistent with
|
|
* equals.
|
|
*/
|
|
public static <K, V> Map<K, V> filterKeys(Map<K, V> unfiltered, final Predicate<? super K> keyPredicate) {
|
|
if (unfiltered instanceof SortedMap) {
|
|
return filterKeys((SortedMap<K, V>) unfiltered, keyPredicate);
|
|
} else if (unfiltered instanceof BiMap) {
|
|
return filterKeys((BiMap<K, V>) unfiltered, keyPredicate);
|
|
}
|
|
checkNotNull(keyPredicate);
|
|
Predicate<Entry<K, ?>> entryPredicate = keyPredicateOnEntries(keyPredicate);
|
|
return (unfiltered instanceof AbstractFilteredMap)
|
|
? filterFiltered((AbstractFilteredMap<K, V>) unfiltered, entryPredicate)
|
|
: new FilteredKeyMap<K, V>(checkNotNull(unfiltered), keyPredicate, entryPredicate);
|
|
}
|
|
|
|
/**
|
|
* Returns a sorted map containing the mappings in {@code unfiltered} whose keys
|
|
* satisfy a predicate. The returned map is a live view of {@code
|
|
* unfiltered}; changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a key that
|
|
* doesn't satisfy the predicate, the map's {@code put()} and {@code putAll()}
|
|
* methods throw an {@link IllegalArgumentException}.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings whose keys satisfy the filter
|
|
* will be removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code keyPredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}. Do not provide a predicate such as
|
|
* {@code Predicates.instanceOf(ArrayList.class)}, which is inconsistent with
|
|
* equals.
|
|
*
|
|
* @since 11.0
|
|
*/
|
|
public static <K, V> SortedMap<K, V> filterKeys(SortedMap<K, V> unfiltered,
|
|
final Predicate<? super K> keyPredicate) {
|
|
// TODO(user): Return a subclass of Maps.FilteredKeyMap for slightly better
|
|
// performance.
|
|
return filterEntries(unfiltered, Maps.<K>keyPredicateOnEntries(keyPredicate));
|
|
}
|
|
|
|
/**
|
|
* Returns a navigable map containing the mappings in {@code unfiltered} whose
|
|
* keys satisfy a predicate. The returned map is a live view of {@code
|
|
* unfiltered}; changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a key that
|
|
* doesn't satisfy the predicate, the map's {@code put()} and {@code putAll()}
|
|
* methods throw an {@link IllegalArgumentException}.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings whose keys satisfy the filter
|
|
* will be removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code keyPredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}. Do not provide a predicate such as
|
|
* {@code Predicates.instanceOf(ArrayList.class)}, which is inconsistent with
|
|
* equals.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V> NavigableMap<K, V> filterKeys(NavigableMap<K, V> unfiltered,
|
|
final Predicate<? super K> keyPredicate) {
|
|
// TODO(user): Return a subclass of Maps.FilteredKeyMap for slightly better
|
|
// performance.
|
|
return filterEntries(unfiltered, Maps.<K>keyPredicateOnEntries(keyPredicate));
|
|
}
|
|
|
|
/**
|
|
* Returns a bimap containing the mappings in {@code unfiltered} whose keys
|
|
* satisfy a predicate. The returned bimap is a live view of {@code unfiltered};
|
|
* changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting bimap's {@code keySet()}, {@code entrySet()}, and
|
|
* {@code values()} views have iterators that don't support {@code remove()},
|
|
* but all other methods are supported by the bimap and its views. When given a
|
|
* key that doesn't satisfy the predicate, the bimap's {@code
|
|
* put()}, {@code forcePut()} and {@code putAll()} methods throw an
|
|
* {@link IllegalArgumentException}.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered bimap or its views, only mappings that satisfy the filter will
|
|
* be removed from the underlying bimap.
|
|
*
|
|
* <p>
|
|
* The returned bimap isn't threadsafe or serializable, even if
|
|
* {@code unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered bimap's methods, such as {@code size()}, iterate across
|
|
* every key in the underlying bimap and determine which satisfy the filter.
|
|
* When a live view is <i>not</i> needed, it may be faster to copy the filtered
|
|
* bimap and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code entryPredicate} must be <i>consistent with equals
|
|
* </i>, as documented at {@link Predicate#apply}.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
public static <K, V> BiMap<K, V> filterKeys(BiMap<K, V> unfiltered, final Predicate<? super K> keyPredicate) {
|
|
checkNotNull(keyPredicate);
|
|
return filterEntries(unfiltered, Maps.<K>keyPredicateOnEntries(keyPredicate));
|
|
}
|
|
|
|
/**
|
|
* Returns a map containing the mappings in {@code unfiltered} whose values
|
|
* satisfy a predicate. The returned map is a live view of {@code unfiltered};
|
|
* changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a value that
|
|
* doesn't satisfy the predicate, the map's {@code put()}, {@code
|
|
* putAll()}, and {@link Entry#setValue} methods throw an
|
|
* {@link IllegalArgumentException}.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings whose values satisfy the filter
|
|
* will be removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code valuePredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}. Do not provide a predicate such as
|
|
* {@code Predicates.instanceOf(ArrayList.class)}, which is inconsistent with
|
|
* equals.
|
|
*/
|
|
public static <K, V> Map<K, V> filterValues(Map<K, V> unfiltered, final Predicate<? super V> valuePredicate) {
|
|
if (unfiltered instanceof SortedMap) {
|
|
return filterValues((SortedMap<K, V>) unfiltered, valuePredicate);
|
|
} else if (unfiltered instanceof BiMap) {
|
|
return filterValues((BiMap<K, V>) unfiltered, valuePredicate);
|
|
}
|
|
return filterEntries(unfiltered, Maps.<V>valuePredicateOnEntries(valuePredicate));
|
|
}
|
|
|
|
/**
|
|
* Returns a sorted map containing the mappings in {@code unfiltered} whose
|
|
* values satisfy a predicate. The returned map is a live view of {@code
|
|
* unfiltered}; changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a value that
|
|
* doesn't satisfy the predicate, the map's {@code put()}, {@code
|
|
* putAll()}, and {@link Entry#setValue} methods throw an
|
|
* {@link IllegalArgumentException}.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings whose values satisfy the filter
|
|
* will be removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code valuePredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}. Do not provide a predicate such as
|
|
* {@code Predicates.instanceOf(ArrayList.class)}, which is inconsistent with
|
|
* equals.
|
|
*
|
|
* @since 11.0
|
|
*/
|
|
public static <K, V> SortedMap<K, V> filterValues(SortedMap<K, V> unfiltered,
|
|
final Predicate<? super V> valuePredicate) {
|
|
return filterEntries(unfiltered, Maps.<V>valuePredicateOnEntries(valuePredicate));
|
|
}
|
|
|
|
/**
|
|
* Returns a navigable map containing the mappings in {@code unfiltered} whose
|
|
* values satisfy a predicate. The returned map is a live view of {@code
|
|
* unfiltered}; changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a value that
|
|
* doesn't satisfy the predicate, the map's {@code put()}, {@code
|
|
* putAll()}, and {@link Entry#setValue} methods throw an
|
|
* {@link IllegalArgumentException}.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings whose values satisfy the filter
|
|
* will be removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code valuePredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}. Do not provide a predicate such as
|
|
* {@code Predicates.instanceOf(ArrayList.class)}, which is inconsistent with
|
|
* equals.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V> NavigableMap<K, V> filterValues(NavigableMap<K, V> unfiltered,
|
|
final Predicate<? super V> valuePredicate) {
|
|
return filterEntries(unfiltered, Maps.<V>valuePredicateOnEntries(valuePredicate));
|
|
}
|
|
|
|
/**
|
|
* Returns a bimap containing the mappings in {@code unfiltered} whose values
|
|
* satisfy a predicate. The returned bimap is a live view of {@code unfiltered};
|
|
* changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting bimap's {@code keySet()}, {@code entrySet()}, and
|
|
* {@code values()} views have iterators that don't support {@code remove()},
|
|
* but all other methods are supported by the bimap and its views. When given a
|
|
* value that doesn't satisfy the predicate, the bimap's {@code put()},
|
|
* {@code forcePut()} and {@code putAll()} methods throw an
|
|
* {@link IllegalArgumentException}. Similarly, the map's entries have a
|
|
* {@link Entry#setValue} method that throws an {@link IllegalArgumentException}
|
|
* when the provided value doesn't satisfy the predicate.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered bimap or its views, only mappings that satisfy the filter will
|
|
* be removed from the underlying bimap.
|
|
*
|
|
* <p>
|
|
* The returned bimap isn't threadsafe or serializable, even if
|
|
* {@code unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered bimap's methods, such as {@code size()}, iterate across
|
|
* every value in the underlying bimap and determine which satisfy the filter.
|
|
* When a live view is <i>not</i> needed, it may be faster to copy the filtered
|
|
* bimap and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code entryPredicate} must be <i>consistent with equals
|
|
* </i>, as documented at {@link Predicate#apply}.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
public static <K, V> BiMap<K, V> filterValues(BiMap<K, V> unfiltered, final Predicate<? super V> valuePredicate) {
|
|
return filterEntries(unfiltered, Maps.<V>valuePredicateOnEntries(valuePredicate));
|
|
}
|
|
|
|
/**
|
|
* Returns a map containing the mappings in {@code unfiltered} that satisfy a
|
|
* predicate. The returned map is a live view of {@code unfiltered}; changes to
|
|
* one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a key/value
|
|
* pair that doesn't satisfy the predicate, the map's {@code put()} and
|
|
* {@code putAll()} methods throw an {@link IllegalArgumentException}.
|
|
* Similarly, the map's entries have a {@link Entry#setValue} method that throws
|
|
* an {@link IllegalArgumentException} when the existing key and the provided
|
|
* value don't satisfy the predicate.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings that satisfy the filter will be
|
|
* removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code entryPredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}.
|
|
*/
|
|
public static <K, V> Map<K, V> filterEntries(Map<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) {
|
|
if (unfiltered instanceof SortedMap) {
|
|
return filterEntries((SortedMap<K, V>) unfiltered, entryPredicate);
|
|
} else if (unfiltered instanceof BiMap) {
|
|
return filterEntries((BiMap<K, V>) unfiltered, entryPredicate);
|
|
}
|
|
checkNotNull(entryPredicate);
|
|
return (unfiltered instanceof AbstractFilteredMap)
|
|
? filterFiltered((AbstractFilteredMap<K, V>) unfiltered, entryPredicate)
|
|
: new FilteredEntryMap<K, V>(checkNotNull(unfiltered), entryPredicate);
|
|
}
|
|
|
|
/**
|
|
* Returns a sorted map containing the mappings in {@code unfiltered} that
|
|
* satisfy a predicate. The returned map is a live view of {@code unfiltered};
|
|
* changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a key/value
|
|
* pair that doesn't satisfy the predicate, the map's {@code put()} and
|
|
* {@code putAll()} methods throw an {@link IllegalArgumentException}.
|
|
* Similarly, the map's entries have a {@link Entry#setValue} method that throws
|
|
* an {@link IllegalArgumentException} when the existing key and the provided
|
|
* value don't satisfy the predicate.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings that satisfy the filter will be
|
|
* removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code entryPredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}.
|
|
*
|
|
* @since 11.0
|
|
*/
|
|
public static <K, V> SortedMap<K, V> filterEntries(SortedMap<K, V> unfiltered,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
return Platform.mapsFilterSortedMap(unfiltered, entryPredicate);
|
|
}
|
|
|
|
static <K, V> SortedMap<K, V> filterSortedIgnoreNavigable(SortedMap<K, V> unfiltered,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
checkNotNull(entryPredicate);
|
|
return (unfiltered instanceof FilteredEntrySortedMap)
|
|
? filterFiltered((FilteredEntrySortedMap<K, V>) unfiltered, entryPredicate)
|
|
: new FilteredEntrySortedMap<K, V>(checkNotNull(unfiltered), entryPredicate);
|
|
}
|
|
|
|
/**
|
|
* Returns a sorted map containing the mappings in {@code unfiltered} that
|
|
* satisfy a predicate. The returned map is a live view of {@code unfiltered};
|
|
* changes to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
|
|
* values()} views have iterators that don't support {@code remove()}, but all
|
|
* other methods are supported by the map and its views. When given a key/value
|
|
* pair that doesn't satisfy the predicate, the map's {@code put()} and
|
|
* {@code putAll()} methods throw an {@link IllegalArgumentException}.
|
|
* Similarly, the map's entries have a {@link Entry#setValue} method that throws
|
|
* an {@link IllegalArgumentException} when the existing key and the provided
|
|
* value don't satisfy the predicate.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered map or its views, only mappings that satisfy the filter will be
|
|
* removed from the underlying map.
|
|
*
|
|
* <p>
|
|
* The returned map isn't threadsafe or serializable, even if {@code
|
|
* unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered map's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying map and determine which satisfy the
|
|
* filter. When a live view is <i>not</i> needed, it may be faster to copy the
|
|
* filtered map and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code entryPredicate} must be <i>consistent with equals</i>,
|
|
* as documented at {@link Predicate#apply}.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V> NavigableMap<K, V> filterEntries(NavigableMap<K, V> unfiltered,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
checkNotNull(entryPredicate);
|
|
return (unfiltered instanceof FilteredEntryNavigableMap)
|
|
? filterFiltered((FilteredEntryNavigableMap<K, V>) unfiltered, entryPredicate)
|
|
: new FilteredEntryNavigableMap<K, V>(checkNotNull(unfiltered), entryPredicate);
|
|
}
|
|
|
|
/**
|
|
* Returns a bimap containing the mappings in {@code unfiltered} that satisfy a
|
|
* predicate. The returned bimap is a live view of {@code unfiltered}; changes
|
|
* to one affect the other.
|
|
*
|
|
* <p>
|
|
* The resulting bimap's {@code keySet()}, {@code entrySet()}, and
|
|
* {@code values()} views have iterators that don't support {@code remove()},
|
|
* but all other methods are supported by the bimap and its views. When given a
|
|
* key/value pair that doesn't satisfy the predicate, the bimap's {@code put()},
|
|
* {@code forcePut()} and {@code putAll()} methods throw an
|
|
* {@link IllegalArgumentException}. Similarly, the map's entries have an
|
|
* {@link Entry#setValue} method that throws an {@link IllegalArgumentException}
|
|
* when the existing key and the provided value don't satisfy the predicate.
|
|
*
|
|
* <p>
|
|
* When methods such as {@code removeAll()} and {@code clear()} are called on
|
|
* the filtered bimap or its views, only mappings that satisfy the filter will
|
|
* be removed from the underlying bimap.
|
|
*
|
|
* <p>
|
|
* The returned bimap isn't threadsafe or serializable, even if
|
|
* {@code unfiltered} is.
|
|
*
|
|
* <p>
|
|
* Many of the filtered bimap's methods, such as {@code size()}, iterate across
|
|
* every key/value mapping in the underlying bimap and determine which satisfy
|
|
* the filter. When a live view is <i>not</i> needed, it may be faster to copy
|
|
* the filtered bimap and use the copy.
|
|
*
|
|
* <p>
|
|
* <b>Warning:</b> {@code entryPredicate} must be <i>consistent with equals
|
|
* </i>, as documented at {@link Predicate#apply}.
|
|
*
|
|
* @since 14.0
|
|
*/
|
|
public static <K, V> BiMap<K, V> filterEntries(BiMap<K, V> unfiltered,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
checkNotNull(unfiltered);
|
|
checkNotNull(entryPredicate);
|
|
return (unfiltered instanceof FilteredEntryBiMap)
|
|
? filterFiltered((FilteredEntryBiMap<K, V>) unfiltered, entryPredicate)
|
|
: new FilteredEntryBiMap<K, V>(unfiltered, entryPredicate);
|
|
}
|
|
|
|
/**
|
|
* Support {@code clear()}, {@code removeAll()}, and {@code retainAll()} when
|
|
* filtering a filtered map.
|
|
*/
|
|
private static <K, V> Map<K, V> filterFiltered(AbstractFilteredMap<K, V> map,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
return new FilteredEntryMap<K, V>(map.unfiltered, Predicates.<Entry<K, V>>and(map.predicate, entryPredicate));
|
|
}
|
|
|
|
private abstract static class AbstractFilteredMap<K, V> extends ImprovedAbstractMap<K, V> {
|
|
final Map<K, V> unfiltered;
|
|
final Predicate<? super Entry<K, V>> predicate;
|
|
|
|
AbstractFilteredMap(Map<K, V> unfiltered, Predicate<? super Entry<K, V>> predicate) {
|
|
this.unfiltered = unfiltered;
|
|
this.predicate = predicate;
|
|
}
|
|
|
|
boolean apply(@Nullable Object key, @Nullable V value) {
|
|
// This method is called only when the key is in the map, implying that
|
|
// key is a K.
|
|
@SuppressWarnings("unchecked")
|
|
K k = (K) key;
|
|
return predicate.apply(Maps.immutableEntry(k, value));
|
|
}
|
|
|
|
@Override
|
|
public V put(K key, V value) {
|
|
checkArgument(apply(key, value));
|
|
return unfiltered.put(key, value);
|
|
}
|
|
|
|
@Override
|
|
public void putAll(Map<? extends K, ? extends V> map) {
|
|
for (Entry<? extends K, ? extends V> entry : map.entrySet()) {
|
|
checkArgument(apply(entry.getKey(), entry.getValue()));
|
|
}
|
|
unfiltered.putAll(map);
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey(Object key) {
|
|
return unfiltered.containsKey(key) && apply(key, unfiltered.get(key));
|
|
}
|
|
|
|
@Override
|
|
public V get(Object key) {
|
|
V value = unfiltered.get(key);
|
|
return ((value != null) && apply(key, value)) ? value : null;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return entrySet().isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public V remove(Object key) {
|
|
return containsKey(key) ? unfiltered.remove(key) : null;
|
|
}
|
|
|
|
@Override
|
|
Collection<V> createValues() {
|
|
return new FilteredMapValues<K, V>(this, unfiltered, predicate);
|
|
}
|
|
}
|
|
|
|
private static final class FilteredMapValues<K, V> extends Maps.Values<K, V> {
|
|
Map<K, V> unfiltered;
|
|
Predicate<? super Entry<K, V>> predicate;
|
|
|
|
FilteredMapValues(Map<K, V> filteredMap, Map<K, V> unfiltered, Predicate<? super Entry<K, V>> predicate) {
|
|
super(filteredMap);
|
|
this.unfiltered = unfiltered;
|
|
this.predicate = predicate;
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object o) {
|
|
return Iterables.removeFirstMatching(unfiltered.entrySet(),
|
|
Predicates.<Entry<K, V>>and(predicate, Maps.<V>valuePredicateOnEntries(equalTo(o)))) != null;
|
|
}
|
|
|
|
private boolean removeIf(Predicate<? super V> valuePredicate) {
|
|
return Iterables.removeIf(unfiltered.entrySet(),
|
|
Predicates.<Entry<K, V>>and(predicate, Maps.<V>valuePredicateOnEntries(valuePredicate)));
|
|
}
|
|
|
|
@Override
|
|
public boolean removeAll(Collection<?> collection) {
|
|
return removeIf(in(collection));
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> collection) {
|
|
return removeIf(not(in(collection)));
|
|
}
|
|
|
|
@Override
|
|
public Object[] toArray() {
|
|
// creating an ArrayList so filtering happens once
|
|
return Lists.newArrayList(iterator()).toArray();
|
|
}
|
|
|
|
@Override
|
|
public <T> T[] toArray(T[] array) {
|
|
return Lists.newArrayList(iterator()).toArray(array);
|
|
}
|
|
}
|
|
|
|
private static class FilteredKeyMap<K, V> extends AbstractFilteredMap<K, V> {
|
|
Predicate<? super K> keyPredicate;
|
|
|
|
FilteredKeyMap(Map<K, V> unfiltered, Predicate<? super K> keyPredicate,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
super(unfiltered, entryPredicate);
|
|
this.keyPredicate = keyPredicate;
|
|
}
|
|
|
|
@Override
|
|
protected Set<Entry<K, V>> createEntrySet() {
|
|
return Sets.filter(unfiltered.entrySet(), predicate);
|
|
}
|
|
|
|
@Override
|
|
Set<K> createKeySet() {
|
|
return Sets.filter(unfiltered.keySet(), keyPredicate);
|
|
}
|
|
|
|
// The cast is called only when the key is in the unfiltered map, implying
|
|
// that key is a K.
|
|
@Override
|
|
@SuppressWarnings("unchecked")
|
|
public boolean containsKey(Object key) {
|
|
return unfiltered.containsKey(key) && keyPredicate.apply((K) key);
|
|
}
|
|
}
|
|
|
|
static class FilteredEntryMap<K, V> extends AbstractFilteredMap<K, V> {
|
|
/**
|
|
* Entries in this set satisfy the predicate, but they don't validate the input
|
|
* to {@code Entry.setValue()}.
|
|
*/
|
|
final Set<Entry<K, V>> filteredEntrySet;
|
|
|
|
FilteredEntryMap(Map<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) {
|
|
super(unfiltered, entryPredicate);
|
|
filteredEntrySet = Sets.filter(unfiltered.entrySet(), predicate);
|
|
}
|
|
|
|
@Override
|
|
protected Set<Entry<K, V>> createEntrySet() {
|
|
return new EntrySet();
|
|
}
|
|
|
|
private class EntrySet extends ForwardingSet<Entry<K, V>> {
|
|
@Override
|
|
protected Set<Entry<K, V>> delegate() {
|
|
return filteredEntrySet;
|
|
}
|
|
|
|
@Override
|
|
public Iterator<Entry<K, V>> iterator() {
|
|
return new TransformedIterator<Entry<K, V>, Entry<K, V>>(filteredEntrySet.iterator()) {
|
|
@Override
|
|
Entry<K, V> transform(final Entry<K, V> entry) {
|
|
return new ForwardingMapEntry<K, V>() {
|
|
@Override
|
|
protected Entry<K, V> delegate() {
|
|
return entry;
|
|
}
|
|
|
|
@Override
|
|
public V setValue(V newValue) {
|
|
checkArgument(apply(getKey(), newValue));
|
|
return super.setValue(newValue);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
@Override
|
|
Set<K> createKeySet() {
|
|
return new KeySet();
|
|
}
|
|
|
|
class KeySet extends Maps.KeySet<K, V> {
|
|
KeySet() {
|
|
super(FilteredEntryMap.this);
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object o) {
|
|
if (containsKey(o)) {
|
|
unfiltered.remove(o);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean removeIf(Predicate<? super K> keyPredicate) {
|
|
return Iterables.removeIf(unfiltered.entrySet(),
|
|
Predicates.<Entry<K, V>>and(predicate, Maps.<K>keyPredicateOnEntries(keyPredicate)));
|
|
}
|
|
|
|
@Override
|
|
public boolean removeAll(Collection<?> c) {
|
|
return removeIf(in(c));
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> c) {
|
|
return removeIf(not(in(c)));
|
|
}
|
|
|
|
@Override
|
|
public Object[] toArray() {
|
|
// creating an ArrayList so filtering happens once
|
|
return Lists.newArrayList(iterator()).toArray();
|
|
}
|
|
|
|
@Override
|
|
public <T> T[] toArray(T[] array) {
|
|
return Lists.newArrayList(iterator()).toArray(array);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Support {@code clear()}, {@code removeAll()}, and {@code retainAll()} when
|
|
* filtering a filtered sorted map.
|
|
*/
|
|
private static <K, V> SortedMap<K, V> filterFiltered(FilteredEntrySortedMap<K, V> map,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
Predicate<Entry<K, V>> predicate = Predicates.and(map.predicate, entryPredicate);
|
|
return new FilteredEntrySortedMap<K, V>(map.sortedMap(), predicate);
|
|
}
|
|
|
|
private static class FilteredEntrySortedMap<K, V> extends FilteredEntryMap<K, V> implements SortedMap<K, V> {
|
|
|
|
FilteredEntrySortedMap(SortedMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) {
|
|
super(unfiltered, entryPredicate);
|
|
}
|
|
|
|
SortedMap<K, V> sortedMap() {
|
|
return (SortedMap<K, V>) unfiltered;
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> keySet() {
|
|
return (SortedSet<K>) super.keySet();
|
|
}
|
|
|
|
@Override
|
|
SortedSet<K> createKeySet() {
|
|
return new SortedKeySet();
|
|
}
|
|
|
|
class SortedKeySet extends KeySet implements SortedSet<K> {
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
return sortedMap().comparator();
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> subSet(K fromElement, K toElement) {
|
|
return (SortedSet<K>) subMap(fromElement, toElement).keySet();
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> headSet(K toElement) {
|
|
return (SortedSet<K>) headMap(toElement).keySet();
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> tailSet(K fromElement) {
|
|
return (SortedSet<K>) tailMap(fromElement).keySet();
|
|
}
|
|
|
|
@Override
|
|
public K first() {
|
|
return firstKey();
|
|
}
|
|
|
|
@Override
|
|
public K last() {
|
|
return lastKey();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
return sortedMap().comparator();
|
|
}
|
|
|
|
@Override
|
|
public K firstKey() {
|
|
// correctly throws NoSuchElementException when filtered map is empty.
|
|
return keySet().iterator().next();
|
|
}
|
|
|
|
@Override
|
|
public K lastKey() {
|
|
SortedMap<K, V> headMap = sortedMap();
|
|
while (true) {
|
|
// correctly throws NoSuchElementException when filtered map is empty.
|
|
K key = headMap.lastKey();
|
|
if (apply(key, unfiltered.get(key))) {
|
|
return key;
|
|
}
|
|
headMap = sortedMap().headMap(key);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> headMap(K toKey) {
|
|
return new FilteredEntrySortedMap<K, V>(sortedMap().headMap(toKey), predicate);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> subMap(K fromKey, K toKey) {
|
|
return new FilteredEntrySortedMap<K, V>(sortedMap().subMap(fromKey, toKey), predicate);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> tailMap(K fromKey) {
|
|
return new FilteredEntrySortedMap<K, V>(sortedMap().tailMap(fromKey), predicate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Support {@code clear()}, {@code removeAll()}, and {@code retainAll()} when
|
|
* filtering a filtered navigable map.
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
private static <K, V> NavigableMap<K, V> filterFiltered(FilteredEntryNavigableMap<K, V> map,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
Predicate<Entry<K, V>> predicate = Predicates.and(map.entryPredicate, entryPredicate);
|
|
return new FilteredEntryNavigableMap<K, V>(map.unfiltered, predicate);
|
|
}
|
|
|
|
@GwtIncompatible("NavigableMap")
|
|
private static class FilteredEntryNavigableMap<K, V> extends AbstractNavigableMap<K, V> {
|
|
/*
|
|
* It's less code to extend AbstractNavigableMap and forward the filtering logic
|
|
* to FilteredEntryMap than to extend FilteredEntrySortedMap and reimplement all
|
|
* the NavigableMap methods.
|
|
*/
|
|
|
|
private final NavigableMap<K, V> unfiltered;
|
|
private final Predicate<? super Entry<K, V>> entryPredicate;
|
|
private final Map<K, V> filteredDelegate;
|
|
|
|
FilteredEntryNavigableMap(NavigableMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) {
|
|
this.unfiltered = checkNotNull(unfiltered);
|
|
this.entryPredicate = entryPredicate;
|
|
this.filteredDelegate = new FilteredEntryMap<K, V>(unfiltered, entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
return unfiltered.comparator();
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> navigableKeySet() {
|
|
return new Maps.NavigableKeySet<K, V>(this) {
|
|
@Override
|
|
public boolean removeAll(Collection<?> c) {
|
|
return Iterators.removeIf(unfiltered.entrySet().iterator(),
|
|
Predicates.<Entry<K, V>>and(entryPredicate, Maps.<K>keyPredicateOnEntries(in(c))));
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> c) {
|
|
return Iterators.removeIf(unfiltered.entrySet().iterator(),
|
|
Predicates.<Entry<K, V>>and(entryPredicate, Maps.<K>keyPredicateOnEntries(not(in(c)))));
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public Collection<V> values() {
|
|
return new FilteredMapValues<K, V>(this, unfiltered, entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
Iterator<Entry<K, V>> entryIterator() {
|
|
return Iterators.filter(unfiltered.entrySet().iterator(), entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
Iterator<Entry<K, V>> descendingEntryIterator() {
|
|
return Iterators.filter(unfiltered.descendingMap().entrySet().iterator(), entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return filteredDelegate.size();
|
|
}
|
|
|
|
@Override
|
|
@Nullable
|
|
public V get(@Nullable Object key) {
|
|
return filteredDelegate.get(key);
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey(@Nullable Object key) {
|
|
return filteredDelegate.containsKey(key);
|
|
}
|
|
|
|
@Override
|
|
public V put(K key, V value) {
|
|
return filteredDelegate.put(key, value);
|
|
}
|
|
|
|
@Override
|
|
public V remove(@Nullable Object key) {
|
|
return filteredDelegate.remove(key);
|
|
}
|
|
|
|
@Override
|
|
public void putAll(Map<? extends K, ? extends V> m) {
|
|
filteredDelegate.putAll(m);
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
filteredDelegate.clear();
|
|
}
|
|
|
|
@Override
|
|
public Set<Entry<K, V>> entrySet() {
|
|
return filteredDelegate.entrySet();
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> pollFirstEntry() {
|
|
return Iterables.removeFirstMatching(unfiltered.entrySet(), entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> pollLastEntry() {
|
|
return Iterables.removeFirstMatching(unfiltered.descendingMap().entrySet(), entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> descendingMap() {
|
|
return filterEntries(unfiltered.descendingMap(), entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
|
|
return filterEntries(unfiltered.subMap(fromKey, fromInclusive, toKey, toInclusive), entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
|
|
return filterEntries(unfiltered.headMap(toKey, inclusive), entryPredicate);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
|
|
return filterEntries(unfiltered.tailMap(fromKey, inclusive), entryPredicate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Support {@code clear()}, {@code removeAll()}, and {@code retainAll()} when
|
|
* filtering a filtered map.
|
|
*/
|
|
private static <K, V> BiMap<K, V> filterFiltered(FilteredEntryBiMap<K, V> map,
|
|
Predicate<? super Entry<K, V>> entryPredicate) {
|
|
Predicate<Entry<K, V>> predicate = Predicates.and(map.predicate, entryPredicate);
|
|
return new FilteredEntryBiMap<K, V>(map.unfiltered(), predicate);
|
|
}
|
|
|
|
static final class FilteredEntryBiMap<K, V> extends FilteredEntryMap<K, V> implements BiMap<K, V> {
|
|
private final BiMap<V, K> inverse;
|
|
|
|
private static <K, V> Predicate<Entry<V, K>> inversePredicate(
|
|
final Predicate<? super Entry<K, V>> forwardPredicate) {
|
|
return new Predicate<Entry<V, K>>() {
|
|
@Override
|
|
public boolean apply(Entry<V, K> input) {
|
|
return forwardPredicate.apply(Maps.immutableEntry(input.getValue(), input.getKey()));
|
|
}
|
|
};
|
|
}
|
|
|
|
FilteredEntryBiMap(BiMap<K, V> delegate, Predicate<? super Entry<K, V>> predicate) {
|
|
super(delegate, predicate);
|
|
this.inverse = new FilteredEntryBiMap<V, K>(delegate.inverse(), inversePredicate(predicate), this);
|
|
}
|
|
|
|
private FilteredEntryBiMap(BiMap<K, V> delegate, Predicate<? super Entry<K, V>> predicate,
|
|
BiMap<V, K> inverse) {
|
|
super(delegate, predicate);
|
|
this.inverse = inverse;
|
|
}
|
|
|
|
BiMap<K, V> unfiltered() {
|
|
return (BiMap<K, V>) unfiltered;
|
|
}
|
|
|
|
@Override
|
|
public V forcePut(@Nullable K key, @Nullable V value) {
|
|
checkArgument(apply(key, value));
|
|
return unfiltered().forcePut(key, value);
|
|
}
|
|
|
|
@Override
|
|
public BiMap<V, K> inverse() {
|
|
return inverse;
|
|
}
|
|
|
|
@Override
|
|
public Set<V> values() {
|
|
return inverse.keySet();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns an unmodifiable view of the specified navigable map. Query operations
|
|
* on the returned map read through to the specified map, and attempts to modify
|
|
* the returned map, whether direct or via its views, result in an
|
|
* {@code UnsupportedOperationException}.
|
|
*
|
|
* <p>
|
|
* The returned navigable map will be serializable if the specified navigable
|
|
* map is serializable.
|
|
*
|
|
* @param map the navigable map for which an unmodifiable view is to be returned
|
|
* @return an unmodifiable view of the specified navigable map
|
|
* @since 12.0
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V> NavigableMap<K, V> unmodifiableNavigableMap(NavigableMap<K, V> map) {
|
|
checkNotNull(map);
|
|
if (map instanceof UnmodifiableNavigableMap) {
|
|
return map;
|
|
} else {
|
|
return new UnmodifiableNavigableMap<K, V>(map);
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
private static <K, V> Entry<K, V> unmodifiableOrNull(@Nullable Entry<K, V> entry) {
|
|
return (entry == null) ? null : Maps.unmodifiableEntry(entry);
|
|
}
|
|
|
|
@GwtIncompatible("NavigableMap")
|
|
static class UnmodifiableNavigableMap<K, V> extends ForwardingSortedMap<K, V>
|
|
implements NavigableMap<K, V>, Serializable {
|
|
private final NavigableMap<K, V> delegate;
|
|
|
|
UnmodifiableNavigableMap(NavigableMap<K, V> delegate) {
|
|
this.delegate = delegate;
|
|
}
|
|
|
|
UnmodifiableNavigableMap(NavigableMap<K, V> delegate, UnmodifiableNavigableMap<K, V> descendingMap) {
|
|
this.delegate = delegate;
|
|
this.descendingMap = descendingMap;
|
|
}
|
|
|
|
@Override
|
|
protected SortedMap<K, V> delegate() {
|
|
return Collections.unmodifiableSortedMap(delegate);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> lowerEntry(K key) {
|
|
return unmodifiableOrNull(delegate.lowerEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K lowerKey(K key) {
|
|
return delegate.lowerKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> floorEntry(K key) {
|
|
return unmodifiableOrNull(delegate.floorEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K floorKey(K key) {
|
|
return delegate.floorKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> ceilingEntry(K key) {
|
|
return unmodifiableOrNull(delegate.ceilingEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K ceilingKey(K key) {
|
|
return delegate.ceilingKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> higherEntry(K key) {
|
|
return unmodifiableOrNull(delegate.higherEntry(key));
|
|
}
|
|
|
|
@Override
|
|
public K higherKey(K key) {
|
|
return delegate.higherKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> firstEntry() {
|
|
return unmodifiableOrNull(delegate.firstEntry());
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> lastEntry() {
|
|
return unmodifiableOrNull(delegate.lastEntry());
|
|
}
|
|
|
|
@Override
|
|
public final Entry<K, V> pollFirstEntry() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public final Entry<K, V> pollLastEntry() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
private transient UnmodifiableNavigableMap<K, V> descendingMap;
|
|
|
|
@Override
|
|
public NavigableMap<K, V> descendingMap() {
|
|
UnmodifiableNavigableMap<K, V> result = descendingMap;
|
|
return (result == null) ? descendingMap = new UnmodifiableNavigableMap<K, V>(delegate.descendingMap(), this)
|
|
: result;
|
|
}
|
|
|
|
@Override
|
|
public Set<K> keySet() {
|
|
return navigableKeySet();
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> navigableKeySet() {
|
|
return Sets.unmodifiableNavigableSet(delegate.navigableKeySet());
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> descendingKeySet() {
|
|
return Sets.unmodifiableNavigableSet(delegate.descendingKeySet());
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> subMap(K fromKey, K toKey) {
|
|
return subMap(fromKey, true, toKey, false);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> headMap(K toKey) {
|
|
return headMap(toKey, false);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> tailMap(K fromKey) {
|
|
return tailMap(fromKey, true);
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
|
|
return Maps.unmodifiableNavigableMap(delegate.subMap(fromKey, fromInclusive, toKey, toInclusive));
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
|
|
return Maps.unmodifiableNavigableMap(delegate.headMap(toKey, inclusive));
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
|
|
return Maps.unmodifiableNavigableMap(delegate.tailMap(fromKey, inclusive));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a synchronized (thread-safe) navigable map backed by the specified
|
|
* navigable map. In order to guarantee serial access, it is critical that
|
|
* <b>all</b> access to the backing navigable map is accomplished through the
|
|
* returned navigable map (or its views).
|
|
*
|
|
* <p>
|
|
* It is imperative that the user manually synchronize on the returned navigable
|
|
* map when iterating over any of its collection views, or the collections views
|
|
* of any of its {@code descendingMap}, {@code subMap}, {@code headMap} or
|
|
* {@code tailMap} views.
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* NavigableMap<K, V> map = synchronizedNavigableMap(new TreeMap<K, V>());
|
|
*
|
|
* // Needn't be in synchronized block
|
|
* NavigableSet<K> set = map.navigableKeySet();
|
|
*
|
|
* synchronized (map) { // Synchronizing on map, not set!
|
|
* Iterator<K> it = set.iterator(); // Must be in synchronized block
|
|
* while (it.hasNext()) {
|
|
* foo(it.next());
|
|
* }
|
|
* }
|
|
* }
|
|
* </pre>
|
|
*
|
|
* <p>
|
|
* or:
|
|
*
|
|
* <pre>
|
|
* {
|
|
* @code
|
|
*
|
|
* NavigableMap<K, V> map = synchronizedNavigableMap(new TreeMap<K, V>());
|
|
* NavigableMap<K, V> map2 = map.subMap(foo, false, bar, true);
|
|
*
|
|
* // Needn't be in synchronized block
|
|
* NavigableSet<K> set2 = map2.descendingKeySet();
|
|
*
|
|
* synchronized (map) { // Synchronizing on map, not map2 or set2!
|
|
* Iterator<K> it = set2.iterator(); // Must be in synchronized block
|
|
* while (it.hasNext()) {
|
|
* foo(it.next());
|
|
* }
|
|
* }
|
|
* }
|
|
* </pre>
|
|
*
|
|
* <p>
|
|
* Failure to follow this advice may result in non-deterministic behavior.
|
|
*
|
|
* <p>
|
|
* The returned navigable map will be serializable if the specified navigable
|
|
* map is serializable.
|
|
*
|
|
* @param navigableMap the navigable map to be "wrapped" in a synchronized
|
|
* navigable map.
|
|
* @return a synchronized view of the specified navigable map.
|
|
* @since 13.0
|
|
*/
|
|
@GwtIncompatible("NavigableMap")
|
|
public static <K, V> NavigableMap<K, V> synchronizedNavigableMap(NavigableMap<K, V> navigableMap) {
|
|
return Synchronized.navigableMap(navigableMap);
|
|
}
|
|
|
|
/**
|
|
* {@code AbstractMap} extension that implements {@link #isEmpty()} as {@code
|
|
* entrySet().isEmpty()} instead of {@code size() == 0} to speed up
|
|
* implementations where {@code size()} is O(n), and it delegates the {@code
|
|
* isEmpty()} methods of its key set and value collection to this
|
|
* implementation.
|
|
*/
|
|
@GwtCompatible
|
|
abstract static class ImprovedAbstractMap<K, V> extends AbstractMap<K, V> {
|
|
/**
|
|
* Creates the entry set to be returned by {@link #entrySet()}. This method is
|
|
* invoked at most once on a given map, at the time when {@code entrySet} is
|
|
* first called.
|
|
*/
|
|
abstract Set<Entry<K, V>> createEntrySet();
|
|
|
|
private transient Set<Entry<K, V>> entrySet;
|
|
|
|
@Override
|
|
public Set<Entry<K, V>> entrySet() {
|
|
Set<Entry<K, V>> result = entrySet;
|
|
return (result == null) ? entrySet = createEntrySet() : result;
|
|
}
|
|
|
|
private transient Set<K> keySet;
|
|
|
|
@Override
|
|
public Set<K> keySet() {
|
|
Set<K> result = keySet;
|
|
return (result == null) ? keySet = createKeySet() : result;
|
|
}
|
|
|
|
Set<K> createKeySet() {
|
|
return new KeySet<K, V>(this);
|
|
}
|
|
|
|
private transient Collection<V> values;
|
|
|
|
@Override
|
|
public Collection<V> values() {
|
|
Collection<V> result = values;
|
|
return (result == null) ? values = createValues() : result;
|
|
}
|
|
|
|
Collection<V> createValues() {
|
|
return new Values<K, V>(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delegates to {@link Map#get}. Returns {@code null} on {@code
|
|
* ClassCastException} and {@code NullPointerException}.
|
|
*/
|
|
static <V> V safeGet(Map<?, V> map, @Nullable Object key) {
|
|
checkNotNull(map);
|
|
try {
|
|
return map.get(key);
|
|
} catch (ClassCastException e) {
|
|
return null;
|
|
} catch (NullPointerException e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delegates to {@link Map#containsKey}. Returns {@code false} on {@code
|
|
* ClassCastException} and {@code NullPointerException}.
|
|
*/
|
|
static boolean safeContainsKey(Map<?, ?> map, Object key) {
|
|
checkNotNull(map);
|
|
try {
|
|
return map.containsKey(key);
|
|
} catch (ClassCastException e) {
|
|
return false;
|
|
} catch (NullPointerException e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delegates to {@link Map#remove}. Returns {@code null} on {@code
|
|
* ClassCastException} and {@code NullPointerException}.
|
|
*/
|
|
static <V> V safeRemove(Map<?, V> map, Object key) {
|
|
checkNotNull(map);
|
|
try {
|
|
return map.remove(key);
|
|
} catch (ClassCastException e) {
|
|
return null;
|
|
} catch (NullPointerException e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* An admittedly inefficient implementation of {@link Map#containsKey}.
|
|
*/
|
|
static boolean containsKeyImpl(Map<?, ?> map, @Nullable Object key) {
|
|
return Iterators.contains(keyIterator(map.entrySet().iterator()), key);
|
|
}
|
|
|
|
/**
|
|
* An implementation of {@link Map#containsValue}.
|
|
*/
|
|
static boolean containsValueImpl(Map<?, ?> map, @Nullable Object value) {
|
|
return Iterators.contains(valueIterator(map.entrySet().iterator()), value);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* <p>
|
|
* 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}
|
|
*/
|
|
static <K, V> boolean containsEntryImpl(Collection<Entry<K, V>> 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.
|
|
*
|
|
* <p>
|
|
* 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
|
|
*/
|
|
static <K, V> boolean removeEntryImpl(Collection<Entry<K, V>> c, Object o) {
|
|
if (!(o instanceof Entry)) {
|
|
return false;
|
|
}
|
|
return c.remove(unmodifiableEntry((Entry<?, ?>) o));
|
|
}
|
|
|
|
/**
|
|
* An implementation of {@link Map#equals}.
|
|
*/
|
|
static boolean equalsImpl(Map<?, ?> map, Object object) {
|
|
if (map == object) {
|
|
return true;
|
|
} else if (object instanceof Map) {
|
|
Map<?, ?> o = (Map<?, ?>) object;
|
|
return map.entrySet().equals(o.entrySet());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static final MapJoiner STANDARD_JOINER = Collections2.STANDARD_JOINER.withKeyValueSeparator("=");
|
|
|
|
/**
|
|
* An implementation of {@link Map#toString}.
|
|
*/
|
|
static String toStringImpl(Map<?, ?> map) {
|
|
StringBuilder sb = Collections2.newStringBuilderForCollection(map.size()).append('{');
|
|
STANDARD_JOINER.appendTo(sb, map);
|
|
return sb.append('}').toString();
|
|
}
|
|
|
|
/**
|
|
* An implementation of {@link Map#putAll}.
|
|
*/
|
|
static <K, V> void putAllImpl(Map<K, V> self, Map<? extends K, ? extends V> map) {
|
|
for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) {
|
|
self.put(entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
|
|
static class KeySet<K, V> extends Sets.ImprovedAbstractSet<K> {
|
|
final Map<K, V> map;
|
|
|
|
KeySet(Map<K, V> map) {
|
|
this.map = checkNotNull(map);
|
|
}
|
|
|
|
Map<K, V> map() {
|
|
return map;
|
|
}
|
|
|
|
@Override
|
|
public Iterator<K> iterator() {
|
|
return keyIterator(map().entrySet().iterator());
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return map().size();
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return map().isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(Object o) {
|
|
return map().containsKey(o);
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object o) {
|
|
if (contains(o)) {
|
|
map().remove(o);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
map().clear();
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
static <K> K keyOrNull(@Nullable Entry<K, ?> entry) {
|
|
return (entry == null) ? null : entry.getKey();
|
|
}
|
|
|
|
@Nullable
|
|
static <V> V valueOrNull(@Nullable Entry<?, V> entry) {
|
|
return (entry == null) ? null : entry.getValue();
|
|
}
|
|
|
|
static class SortedKeySet<K, V> extends KeySet<K, V> implements SortedSet<K> {
|
|
SortedKeySet(SortedMap<K, V> map) {
|
|
super(map);
|
|
}
|
|
|
|
@Override
|
|
SortedMap<K, V> map() {
|
|
return (SortedMap<K, V>) super.map();
|
|
}
|
|
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
return map().comparator();
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> subSet(K fromElement, K toElement) {
|
|
return new SortedKeySet<K, V>(map().subMap(fromElement, toElement));
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> headSet(K toElement) {
|
|
return new SortedKeySet<K, V>(map().headMap(toElement));
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> tailSet(K fromElement) {
|
|
return new SortedKeySet<K, V>(map().tailMap(fromElement));
|
|
}
|
|
|
|
@Override
|
|
public K first() {
|
|
return map().firstKey();
|
|
}
|
|
|
|
@Override
|
|
public K last() {
|
|
return map().lastKey();
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible("NavigableMap")
|
|
static class NavigableKeySet<K, V> extends SortedKeySet<K, V> implements NavigableSet<K> {
|
|
NavigableKeySet(NavigableMap<K, V> map) {
|
|
super(map);
|
|
}
|
|
|
|
@Override
|
|
NavigableMap<K, V> map() {
|
|
return (NavigableMap<K, V>) map;
|
|
}
|
|
|
|
@Override
|
|
public K lower(K e) {
|
|
return map().lowerKey(e);
|
|
}
|
|
|
|
@Override
|
|
public K floor(K e) {
|
|
return map().floorKey(e);
|
|
}
|
|
|
|
@Override
|
|
public K ceiling(K e) {
|
|
return map().ceilingKey(e);
|
|
}
|
|
|
|
@Override
|
|
public K higher(K e) {
|
|
return map().higherKey(e);
|
|
}
|
|
|
|
@Override
|
|
public K pollFirst() {
|
|
return keyOrNull(map().pollFirstEntry());
|
|
}
|
|
|
|
@Override
|
|
public K pollLast() {
|
|
return keyOrNull(map().pollLastEntry());
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> descendingSet() {
|
|
return map().descendingKeySet();
|
|
}
|
|
|
|
@Override
|
|
public Iterator<K> descendingIterator() {
|
|
return descendingSet().iterator();
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> subSet(K fromElement, boolean fromInclusive, K toElement, boolean toInclusive) {
|
|
return map().subMap(fromElement, fromInclusive, toElement, toInclusive).navigableKeySet();
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> headSet(K toElement, boolean inclusive) {
|
|
return map().headMap(toElement, inclusive).navigableKeySet();
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> tailSet(K fromElement, boolean inclusive) {
|
|
return map().tailMap(fromElement, inclusive).navigableKeySet();
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> subSet(K fromElement, K toElement) {
|
|
return subSet(fromElement, true, toElement, false);
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> headSet(K toElement) {
|
|
return headSet(toElement, false);
|
|
}
|
|
|
|
@Override
|
|
public SortedSet<K> tailSet(K fromElement) {
|
|
return tailSet(fromElement, true);
|
|
}
|
|
}
|
|
|
|
static class Values<K, V> extends AbstractCollection<V> {
|
|
final Map<K, V> map;
|
|
|
|
Values(Map<K, V> map) {
|
|
this.map = checkNotNull(map);
|
|
}
|
|
|
|
final Map<K, V> map() {
|
|
return map;
|
|
}
|
|
|
|
@Override
|
|
public Iterator<V> iterator() {
|
|
return valueIterator(map().entrySet().iterator());
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object o) {
|
|
try {
|
|
return super.remove(o);
|
|
} catch (UnsupportedOperationException e) {
|
|
for (Entry<K, V> entry : map().entrySet()) {
|
|
if (Objects.equal(o, entry.getValue())) {
|
|
map().remove(entry.getKey());
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean removeAll(Collection<?> c) {
|
|
try {
|
|
return super.removeAll(checkNotNull(c));
|
|
} catch (UnsupportedOperationException e) {
|
|
Set<K> toRemove = Sets.newHashSet();
|
|
for (Entry<K, V> entry : map().entrySet()) {
|
|
if (c.contains(entry.getValue())) {
|
|
toRemove.add(entry.getKey());
|
|
}
|
|
}
|
|
return map().keySet().removeAll(toRemove);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> c) {
|
|
try {
|
|
return super.retainAll(checkNotNull(c));
|
|
} catch (UnsupportedOperationException e) {
|
|
Set<K> toRetain = Sets.newHashSet();
|
|
for (Entry<K, V> entry : map().entrySet()) {
|
|
if (c.contains(entry.getValue())) {
|
|
toRetain.add(entry.getKey());
|
|
}
|
|
}
|
|
return map().keySet().retainAll(toRetain);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return map().size();
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return map().isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(@Nullable Object o) {
|
|
return map().containsValue(o);
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
map().clear();
|
|
}
|
|
}
|
|
|
|
abstract static class EntrySet<K, V> extends Sets.ImprovedAbstractSet<Entry<K, V>> {
|
|
abstract Map<K, V> map();
|
|
|
|
@Override
|
|
public int size() {
|
|
return map().size();
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
map().clear();
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(Object o) {
|
|
if (o instanceof Entry) {
|
|
Entry<?, ?> entry = (Entry<?, ?>) o;
|
|
Object key = entry.getKey();
|
|
V value = Maps.safeGet(map(), key);
|
|
return Objects.equal(value, entry.getValue()) && (value != null || map().containsKey(key));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return map().isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object o) {
|
|
if (contains(o)) {
|
|
Entry<?, ?> entry = (Entry<?, ?>) o;
|
|
return map().keySet().remove(entry.getKey());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean removeAll(Collection<?> c) {
|
|
try {
|
|
return super.removeAll(checkNotNull(c));
|
|
} catch (UnsupportedOperationException e) {
|
|
// if the iterators don't support remove
|
|
return Sets.removeAllImpl(this, c.iterator());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> c) {
|
|
try {
|
|
return super.retainAll(checkNotNull(c));
|
|
} catch (UnsupportedOperationException e) {
|
|
// if the iterators don't support remove
|
|
Set<Object> keys = Sets.newHashSetWithExpectedSize(c.size());
|
|
for (Object o : c) {
|
|
if (contains(o)) {
|
|
Entry<?, ?> entry = (Entry<?, ?>) o;
|
|
keys.add(entry.getKey());
|
|
}
|
|
}
|
|
return map().keySet().retainAll(keys);
|
|
}
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible("NavigableMap")
|
|
abstract static class DescendingMap<K, V> extends ForwardingMap<K, V> implements NavigableMap<K, V> {
|
|
|
|
abstract NavigableMap<K, V> forward();
|
|
|
|
@Override
|
|
protected final Map<K, V> delegate() {
|
|
return forward();
|
|
}
|
|
|
|
private transient Comparator<? super K> comparator;
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public Comparator<? super K> comparator() {
|
|
Comparator<? super K> result = comparator;
|
|
if (result == null) {
|
|
Comparator<? super K> forwardCmp = forward().comparator();
|
|
if (forwardCmp == null) {
|
|
forwardCmp = (Comparator) Ordering.natural();
|
|
}
|
|
result = comparator = reverse(forwardCmp);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// If we inline this, we get a javac error.
|
|
private static <T> Ordering<T> reverse(Comparator<T> forward) {
|
|
return Ordering.from(forward).reverse();
|
|
}
|
|
|
|
@Override
|
|
public K firstKey() {
|
|
return forward().lastKey();
|
|
}
|
|
|
|
@Override
|
|
public K lastKey() {
|
|
return forward().firstKey();
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> lowerEntry(K key) {
|
|
return forward().higherEntry(key);
|
|
}
|
|
|
|
@Override
|
|
public K lowerKey(K key) {
|
|
return forward().higherKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> floorEntry(K key) {
|
|
return forward().ceilingEntry(key);
|
|
}
|
|
|
|
@Override
|
|
public K floorKey(K key) {
|
|
return forward().ceilingKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> ceilingEntry(K key) {
|
|
return forward().floorEntry(key);
|
|
}
|
|
|
|
@Override
|
|
public K ceilingKey(K key) {
|
|
return forward().floorKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> higherEntry(K key) {
|
|
return forward().lowerEntry(key);
|
|
}
|
|
|
|
@Override
|
|
public K higherKey(K key) {
|
|
return forward().lowerKey(key);
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> firstEntry() {
|
|
return forward().lastEntry();
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> lastEntry() {
|
|
return forward().firstEntry();
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> pollFirstEntry() {
|
|
return forward().pollLastEntry();
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> pollLastEntry() {
|
|
return forward().pollFirstEntry();
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> descendingMap() {
|
|
return forward();
|
|
}
|
|
|
|
private transient Set<Entry<K, V>> entrySet;
|
|
|
|
@Override
|
|
public Set<Entry<K, V>> entrySet() {
|
|
Set<Entry<K, V>> result = entrySet;
|
|
return (result == null) ? entrySet = createEntrySet() : result;
|
|
}
|
|
|
|
abstract Iterator<Entry<K, V>> entryIterator();
|
|
|
|
Set<Entry<K, V>> createEntrySet() {
|
|
return new EntrySet<K, V>() {
|
|
@Override
|
|
Map<K, V> map() {
|
|
return DescendingMap.this;
|
|
}
|
|
|
|
@Override
|
|
public Iterator<Entry<K, V>> iterator() {
|
|
return entryIterator();
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public Set<K> keySet() {
|
|
return navigableKeySet();
|
|
}
|
|
|
|
private transient NavigableSet<K> navigableKeySet;
|
|
|
|
@Override
|
|
public NavigableSet<K> navigableKeySet() {
|
|
NavigableSet<K> result = navigableKeySet;
|
|
return (result == null) ? navigableKeySet = new NavigableKeySet<K, V>(this) : result;
|
|
}
|
|
|
|
@Override
|
|
public NavigableSet<K> descendingKeySet() {
|
|
return forward().navigableKeySet();
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
|
|
return forward().subMap(toKey, toInclusive, fromKey, fromInclusive).descendingMap();
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
|
|
return forward().tailMap(toKey, inclusive).descendingMap();
|
|
}
|
|
|
|
@Override
|
|
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
|
|
return forward().headMap(fromKey, inclusive).descendingMap();
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> subMap(K fromKey, K toKey) {
|
|
return subMap(fromKey, true, toKey, false);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> headMap(K toKey) {
|
|
return headMap(toKey, false);
|
|
}
|
|
|
|
@Override
|
|
public SortedMap<K, V> tailMap(K fromKey) {
|
|
return tailMap(fromKey, true);
|
|
}
|
|
|
|
@Override
|
|
public Collection<V> values() {
|
|
return new Values<K, V>(this);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return standardToString();
|
|
}
|
|
}
|
|
}
|