All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.google.common.collect.ImmutableSortedMap Maven / Gradle / Ivy

Go to download

Guava is a suite of core and expanded libraries that include utility classes, Google's collections, I/O classes, and much more. This project includes GWT-friendly sources.

There is a newer version: 33.4.0-jre
Show newest version
/*
 * Copyright (C) 2009 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.collect.CollectPreconditions.checkEntryNotNull;
import static com.google.common.collect.Maps.keyOrNull;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.j2objc.annotations.WeakOuter;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.SortedMap;
import java.util.Spliterator;
import java.util.TreeMap;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A {@link NavigableMap} whose contents will never change, with many other important properties
 * detailed at {@link ImmutableCollection}.
 *
 * 

Warning: as with any sorted collection, you are strongly advised not to use a {@link * Comparator} or {@link Comparable} type whose comparison behavior is inconsistent with * equals. That is, {@code a.compareTo(b)} or {@code comparator.compare(a, b)} should equal zero * if and only if {@code a.equals(b)}. If this advice is not followed, the resulting map will * not correctly obey its specification. * *

See the Guava User Guide article on immutable collections. * * @author Jared Levy * @author Louis Wasserman * @since 2.0 (implements {@code NavigableMap} since 12.0) */ @GwtCompatible(serializable = true, emulated = true) public final class ImmutableSortedMap extends ImmutableSortedMapFauxverideShim implements NavigableMap { /** * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose * keys and values are the result of applying the provided mapping functions to the input * elements. The generated map is sorted by the specified comparator. * *

If the mapped keys contain duplicates (according to the specified comparator), an {@code * IllegalArgumentException} is thrown when the collection operation is performed. (This differs * from the {@code Collector} returned by {@link Collectors#toMap(Function, Function)}, which * throws an {@code IllegalStateException}.) * * @since 21.0 */ @Beta public static Collector> toImmutableSortedMap( Comparator comparator, Function keyFunction, Function valueFunction) { return CollectCollectors.toImmutableSortedMap(comparator, keyFunction, valueFunction); } /** * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose * keys and values are the result of applying the provided mapping functions to the input * elements. * *

If the mapped keys contain duplicates (according to the comparator), the the values are * merged using the specified merging function. Entries will appear in the encounter order of the * first occurrence of the key. * * @since 21.0 */ @Beta public static Collector> toImmutableSortedMap( Comparator comparator, Function keyFunction, Function valueFunction, BinaryOperator mergeFunction) { checkNotNull(comparator); checkNotNull(keyFunction); checkNotNull(valueFunction); checkNotNull(mergeFunction); return Collectors.collectingAndThen( Collectors.toMap( keyFunction, valueFunction, mergeFunction, () -> new TreeMap(comparator)), ImmutableSortedMap::copyOfSorted); } /* * TODO(kevinb): Confirm that ImmutableSortedMap is faster to construct and * uses less memory than TreeMap; then say so in the class Javadoc. */ private static final Comparator NATURAL_ORDER = Ordering.natural(); private static final ImmutableSortedMap NATURAL_EMPTY_MAP = new ImmutableSortedMap<>( ImmutableSortedSet.emptySet(Ordering.natural()), ImmutableList.of()); static ImmutableSortedMap emptyMap(Comparator comparator) { if (Ordering.natural().equals(comparator)) { return of(); } else { return new ImmutableSortedMap<>( ImmutableSortedSet.emptySet(comparator), ImmutableList.of()); } } /** Returns the empty sorted map. */ @SuppressWarnings("unchecked") // unsafe, comparator() returns a comparator on the specified type // TODO(kevinb): evaluate whether or not of().comparator() should return null public static ImmutableSortedMap of() { return (ImmutableSortedMap) NATURAL_EMPTY_MAP; } /** Returns an immutable map containing a single entry. */ public static , V> ImmutableSortedMap of(K k1, V v1) { return of(Ordering.natural(), k1, v1); } /** Returns an immutable map containing a single entry. */ private static ImmutableSortedMap of(Comparator comparator, K k1, V v1) { return new ImmutableSortedMap<>( new RegularImmutableSortedSet(ImmutableList.of(k1), checkNotNull(comparator)), ImmutableList.of(v1)); } /** * Returns an immutable sorted map containing the given entries, sorted by the natural ordering of * their keys. * * @throws IllegalArgumentException if the two keys are equal according to their natural ordering */ @SuppressWarnings("unchecked") public static , V> ImmutableSortedMap of( K k1, V v1, K k2, V v2) { return ofEntries(entryOf(k1, v1), entryOf(k2, v2)); } /** * Returns an immutable sorted map containing the given entries, sorted by the natural ordering of * their keys. * * @throws IllegalArgumentException if any two keys are equal according to their natural ordering */ @SuppressWarnings("unchecked") public static , V> ImmutableSortedMap of( K k1, V v1, K k2, V v2, K k3, V v3) { return ofEntries(entryOf(k1, v1), entryOf(k2, v2), entryOf(k3, v3)); } /** * Returns an immutable sorted map containing the given entries, sorted by the natural ordering of * their keys. * * @throws IllegalArgumentException if any two keys are equal according to their natural ordering */ @SuppressWarnings("unchecked") public static , V> ImmutableSortedMap of( K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) { return ofEntries(entryOf(k1, v1), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4)); } /** * Returns an immutable sorted map containing the given entries, sorted by the natural ordering of * their keys. * * @throws IllegalArgumentException if any two keys are equal according to their natural ordering */ @SuppressWarnings("unchecked") public static , V> ImmutableSortedMap of( K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) { return ofEntries( entryOf(k1, v1), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5)); } private static , V> ImmutableSortedMap ofEntries( Entry... entries) { return fromEntries(Ordering.natural(), false, entries, entries.length); } /** * Returns an immutable map containing the same entries as {@code map}, sorted by the natural * ordering of the keys. * *

Despite the method name, this method attempts to avoid actually copying the data when it is * safe to do so. The exact circumstances under which a copy will or will not be performed are * undocumented and subject to change. * *

This method is not type-safe, as it may be called on a map with keys that are not mutually * comparable. * * @throws ClassCastException if the keys in {@code map} are not mutually comparable * @throws NullPointerException if any key or value in {@code map} is null * @throws IllegalArgumentException if any two keys are equal according to their natural ordering */ public static ImmutableSortedMap copyOf(Map map) { // Hack around K not being a subtype of Comparable. // Unsafe, see ImmutableSortedSetFauxverideShim. @SuppressWarnings("unchecked") Ordering naturalOrder = (Ordering) NATURAL_ORDER; return copyOfInternal(map, naturalOrder); } /** * Returns an immutable map containing the same entries as {@code map}, with keys sorted by the * provided comparator. * *

Despite the method name, this method attempts to avoid actually copying the data when it is * safe to do so. The exact circumstances under which a copy will or will not be performed are * undocumented and subject to change. * * @throws NullPointerException if any key or value in {@code map} is null * @throws IllegalArgumentException if any two keys are equal according to the comparator */ public static ImmutableSortedMap copyOf( Map map, Comparator comparator) { return copyOfInternal(map, checkNotNull(comparator)); } /** * Returns an immutable map containing the given entries, with keys sorted by the provided * comparator. * *

This method is not type-safe, as it may be called on a map with keys that are not mutually * comparable. * * @throws NullPointerException if any key or value in {@code map} is null * @throws IllegalArgumentException if any two keys are equal according to the comparator * @since 19.0 */ @Beta public static ImmutableSortedMap copyOf( Iterable> entries) { // Hack around K not being a subtype of Comparable. // Unsafe, see ImmutableSortedSetFauxverideShim. @SuppressWarnings("unchecked") Ordering naturalOrder = (Ordering) NATURAL_ORDER; return copyOf(entries, naturalOrder); } /** * Returns an immutable map containing the given entries, with keys sorted by the provided * comparator. * * @throws NullPointerException if any key or value in {@code map} is null * @throws IllegalArgumentException if any two keys are equal according to the comparator * @since 19.0 */ @Beta public static ImmutableSortedMap copyOf( Iterable> entries, Comparator comparator) { return fromEntries(checkNotNull(comparator), false, entries); } /** * Returns an immutable map containing the same entries as the provided sorted map, with the same * ordering. * *

Despite the method name, this method attempts to avoid actually copying the data when it is * safe to do so. The exact circumstances under which a copy will or will not be performed are * undocumented and subject to change. * * @throws NullPointerException if any key or value in {@code map} is null */ @SuppressWarnings("unchecked") public static ImmutableSortedMap copyOfSorted(SortedMap map) { Comparator comparator = map.comparator(); if (comparator == null) { // If map has a null comparator, the keys should have a natural ordering, // even though K doesn't explicitly implement Comparable. comparator = (Comparator) NATURAL_ORDER; } if (map instanceof ImmutableSortedMap) { // TODO(kevinb): Prove that this cast is safe, even though // Collections.unmodifiableSortedMap requires the same key type. @SuppressWarnings("unchecked") ImmutableSortedMap kvMap = (ImmutableSortedMap) map; if (!kvMap.isPartialView()) { return kvMap; } } return fromEntries(comparator, true, map.entrySet()); } private static ImmutableSortedMap copyOfInternal( Map map, Comparator comparator) { boolean sameComparator = false; if (map instanceof SortedMap) { SortedMap sortedMap = (SortedMap) map; Comparator comparator2 = sortedMap.comparator(); sameComparator = (comparator2 == null) ? comparator == NATURAL_ORDER : comparator.equals(comparator2); } if (sameComparator && (map instanceof ImmutableSortedMap)) { // TODO(kevinb): Prove that this cast is safe, even though // Collections.unmodifiableSortedMap requires the same key type. @SuppressWarnings("unchecked") ImmutableSortedMap kvMap = (ImmutableSortedMap) map; if (!kvMap.isPartialView()) { return kvMap; } } return fromEntries(comparator, sameComparator, map.entrySet()); } /** * Accepts a collection of possibly-null entries. If {@code sameComparator}, then it is assumed * that they do not need to be sorted or checked for dupes. */ private static ImmutableSortedMap fromEntries( Comparator comparator, boolean sameComparator, Iterable> entries) { // "adding" type params to an array of a raw type should be safe as // long as no one can ever cast that same array instance back to a // raw type. @SuppressWarnings("unchecked") Entry[] entryArray = (Entry[]) Iterables.toArray(entries, EMPTY_ENTRY_ARRAY); return fromEntries(comparator, sameComparator, entryArray, entryArray.length); } private static ImmutableSortedMap fromEntries( final Comparator comparator, boolean sameComparator, Entry[] entryArray, int size) { switch (size) { case 0: return emptyMap(comparator); case 1: return ImmutableSortedMap.of( comparator, entryArray[0].getKey(), entryArray[0].getValue()); default: Object[] keys = new Object[size]; Object[] values = new Object[size]; if (sameComparator) { // Need to check for nulls, but don't need to sort or validate. for (int i = 0; i < size; i++) { Object key = entryArray[i].getKey(); Object value = entryArray[i].getValue(); checkEntryNotNull(key, value); keys[i] = key; values[i] = value; } } else { // Need to sort and check for nulls and dupes. // Inline the Comparator implementation rather than transforming with a Function // to save code size. Arrays.sort( entryArray, 0, size, new Comparator>() { @Override public int compare(Entry e1, Entry e2) { return comparator.compare(e1.getKey(), e2.getKey()); } }); K prevKey = entryArray[0].getKey(); keys[0] = prevKey; values[0] = entryArray[0].getValue(); checkEntryNotNull(keys[0], values[0]); for (int i = 1; i < size; i++) { K key = entryArray[i].getKey(); V value = entryArray[i].getValue(); checkEntryNotNull(key, value); keys[i] = key; values[i] = value; checkNoConflict( comparator.compare(prevKey, key) != 0, "key", entryArray[i - 1], entryArray[i]); prevKey = key; } } return new ImmutableSortedMap<>( new RegularImmutableSortedSet(new RegularImmutableList(keys), comparator), new RegularImmutableList(values)); } } /** * Returns a builder that creates immutable sorted maps whose keys are ordered by their natural * ordering. The sorted maps use {@link Ordering#natural()} as the comparator. */ public static , V> Builder naturalOrder() { return new Builder<>(Ordering.natural()); } /** * Returns a builder that creates immutable sorted maps with an explicit comparator. If the * comparator has a more general type than the map's keys, such as creating a {@code * SortedMap} with a {@code Comparator}, use the {@link Builder} * constructor instead. * * @throws NullPointerException if {@code comparator} is null */ public static Builder orderedBy(Comparator comparator) { return new Builder<>(comparator); } /** * Returns a builder that creates immutable sorted maps whose keys are ordered by the reverse of * their natural ordering. */ public static , V> Builder reverseOrder() { return new Builder<>(Ordering.natural().reverse()); } /** * A builder for creating immutable sorted map instances, especially {@code public static final} * maps ("constant maps"). Example: * *

{@code
   * static final ImmutableSortedMap INT_TO_WORD =
   *     new ImmutableSortedMap.Builder(Ordering.natural())
   *         .put(1, "one")
   *         .put(2, "two")
   *         .put(3, "three")
   *         .build();
   * }
* *

For small immutable sorted maps, the {@code ImmutableSortedMap.of()} methods are even * more convenient. * *

Builder instances can be reused - it is safe to call {@link #build} multiple times to build * multiple maps in series. Each map is a superset of the maps created before it. * * @since 2.0 */ public static class Builder extends ImmutableMap.Builder { private final Comparator comparator; /** * Creates a new builder. The returned builder is equivalent to the builder generated by {@link * ImmutableSortedMap#orderedBy}. */ @SuppressWarnings("unchecked") public Builder(Comparator comparator) { this.comparator = checkNotNull(comparator); } /** * Associates {@code key} with {@code value} in the built map. Duplicate keys, according to the * comparator (which might be the keys' natural order), are not allowed, and will cause {@link * #build} to fail. */ @CanIgnoreReturnValue @Override public Builder put(K key, V value) { super.put(key, value); return this; } /** * Adds the given {@code entry} to the map, making it immutable if necessary. Duplicate keys, * according to the comparator (which might be the keys' natural order), are not allowed, and * will cause {@link #build} to fail. * * @since 11.0 */ @CanIgnoreReturnValue @Override public Builder put(Entry entry) { super.put(entry); return this; } /** * Associates all of the given map's keys and values in the built map. Duplicate keys, according * to the comparator (which might be the keys' natural order), are not allowed, and will cause * {@link #build} to fail. * * @throws NullPointerException if any key or value in {@code map} is null */ @CanIgnoreReturnValue @Override public Builder putAll(Map map) { super.putAll(map); return this; } /** * Adds all the given entries to the built map. Duplicate keys, according to the comparator * (which might be the keys' natural order), are not allowed, and will cause {@link #build} to * fail. * * @throws NullPointerException if any key, value, or entry is null * @since 19.0 */ @CanIgnoreReturnValue @Beta @Override public Builder putAll(Iterable> entries) { super.putAll(entries); return this; } /** * Throws an {@code UnsupportedOperationException}. * * @since 19.0 * @deprecated Unsupported by ImmutableSortedMap.Builder. */ @CanIgnoreReturnValue @Beta @Override @Deprecated public Builder orderEntriesByValue(Comparator valueComparator) { throw new UnsupportedOperationException("Not available on ImmutableSortedMap.Builder"); } @Override Builder combine(ImmutableMap.Builder other) { super.combine(other); return this; } /** * Returns a newly-created immutable sorted map. * * @throws IllegalArgumentException if any two keys are equal according to the comparator (which * might be the keys' natural order) */ @Override public ImmutableSortedMap build() { switch (size) { case 0: return emptyMap(comparator); case 1: return of(comparator, entries[0].getKey(), entries[0].getValue()); default: return fromEntries(comparator, false, entries, size); } } } private final transient RegularImmutableSortedSet keySet; private final transient ImmutableList valueList; private transient ImmutableSortedMap descendingMap; ImmutableSortedMap(RegularImmutableSortedSet keySet, ImmutableList valueList) { this(keySet, valueList, null); } ImmutableSortedMap( RegularImmutableSortedSet keySet, ImmutableList valueList, ImmutableSortedMap descendingMap) { this.keySet = keySet; this.valueList = valueList; this.descendingMap = descendingMap; } @Override public int size() { return valueList.size(); } @Override public void forEach(BiConsumer action) { checkNotNull(action); ImmutableList keyList = keySet.asList(); for (int i = 0; i < size(); i++) { action.accept(keyList.get(i), valueList.get(i)); } } @Override public V get(@Nullable Object key) { int index = keySet.indexOf(key); return (index == -1) ? null : valueList.get(index); } @Override boolean isPartialView() { return keySet.isPartialView() || valueList.isPartialView(); } /** Returns an immutable set of the mappings in this map, sorted by the key ordering. */ @Override public ImmutableSet> entrySet() { return super.entrySet(); } @Override ImmutableSet> createEntrySet() { @WeakOuter class EntrySet extends ImmutableMapEntrySet { @Override public UnmodifiableIterator> iterator() { return asList().iterator(); } @Override public Spliterator> spliterator() { return asList().spliterator(); } @Override public void forEach(Consumer> action) { asList().forEach(action); } @Override ImmutableList> createAsList() { return new ImmutableAsList>() { @Override public Entry get(int index) { return new AbstractMap.SimpleImmutableEntry<>( keySet.asList().get(index), valueList.get(index)); } @Override public Spliterator> spliterator() { return CollectSpliterators.indexed( size(), ImmutableSet.SPLITERATOR_CHARACTERISTICS, this::get); } @Override ImmutableCollection> delegateCollection() { return EntrySet.this; } }; } @Override ImmutableMap map() { return ImmutableSortedMap.this; } } return isEmpty() ? ImmutableSet.>of() : new EntrySet(); } /** Returns an immutable sorted set of the keys in this map. */ @Override public ImmutableSortedSet keySet() { return keySet; } @Override ImmutableSet createKeySet() { throw new AssertionError("should never be called"); } /** * Returns an immutable collection of the values in this map, sorted by the ordering of the * corresponding keys. */ @Override public ImmutableCollection values() { return valueList; } @Override ImmutableCollection createValues() { throw new AssertionError("should never be called"); } /** * Returns the comparator that orders the keys, which is {@link Ordering#natural()} when the * natural ordering of the keys is used. Note that its behavior is not consistent with {@link * TreeMap#comparator()}, which returns {@code null} to indicate natural ordering. */ @Override public Comparator comparator() { return keySet().comparator(); } @Override public K firstKey() { return keySet().first(); } @Override public K lastKey() { return keySet().last(); } private ImmutableSortedMap getSubMap(int fromIndex, int toIndex) { if (fromIndex == 0 && toIndex == size()) { return this; } else if (fromIndex == toIndex) { return emptyMap(comparator()); } else { return new ImmutableSortedMap<>( keySet.getSubSet(fromIndex, toIndex), valueList.subList(fromIndex, toIndex)); } } /** * This method returns a {@code ImmutableSortedMap}, consisting of the entries whose keys are less * than {@code toKey}. * *

The {@link SortedMap#headMap} documentation states that a submap of a submap throws an * {@link IllegalArgumentException} if passed a {@code toKey} greater than an earlier {@code * toKey}. However, this method doesn't throw an exception in that situation, but instead keeps * the original {@code toKey}. */ @Override public ImmutableSortedMap headMap(K toKey) { return headMap(toKey, false); } /** * This method returns a {@code ImmutableSortedMap}, consisting of the entries whose keys are less * than (or equal to, if {@code inclusive}) {@code toKey}. * *

The {@link SortedMap#headMap} documentation states that a submap of a submap throws an * {@link IllegalArgumentException} if passed a {@code toKey} greater than an earlier {@code * toKey}. However, this method doesn't throw an exception in that situation, but instead keeps * the original {@code toKey}. * * @since 12.0 */ @Override public ImmutableSortedMap headMap(K toKey, boolean inclusive) { return getSubMap(0, keySet.headIndex(checkNotNull(toKey), inclusive)); } /** * This method returns a {@code ImmutableSortedMap}, consisting of the entries whose keys ranges * from {@code fromKey}, inclusive, to {@code toKey}, exclusive. * *

The {@link SortedMap#subMap} documentation states that a submap of a submap throws an {@link * IllegalArgumentException} if passed a {@code fromKey} less than an earlier {@code fromKey}. * However, this method doesn't throw an exception in that situation, but instead keeps the * original {@code fromKey}. Similarly, this method keeps the original {@code toKey}, instead of * throwing an exception, if passed a {@code toKey} greater than an earlier {@code toKey}. */ @Override public ImmutableSortedMap subMap(K fromKey, K toKey) { return subMap(fromKey, true, toKey, false); } /** * This method returns a {@code ImmutableSortedMap}, consisting of the entries whose keys ranges * from {@code fromKey} to {@code toKey}, inclusive or exclusive as indicated by the boolean * flags. * *

The {@link SortedMap#subMap} documentation states that a submap of a submap throws an {@link * IllegalArgumentException} if passed a {@code fromKey} less than an earlier {@code fromKey}. * However, this method doesn't throw an exception in that situation, but instead keeps the * original {@code fromKey}. Similarly, this method keeps the original {@code toKey}, instead of * throwing an exception, if passed a {@code toKey} greater than an earlier {@code toKey}. * * @since 12.0 */ @Override public ImmutableSortedMap subMap( K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) { checkNotNull(fromKey); checkNotNull(toKey); checkArgument( comparator().compare(fromKey, toKey) <= 0, "expected fromKey <= toKey but %s > %s", fromKey, toKey); return headMap(toKey, toInclusive).tailMap(fromKey, fromInclusive); } /** * This method returns a {@code ImmutableSortedMap}, consisting of the entries whose keys are * greater than or equals to {@code fromKey}. * *

The {@link SortedMap#tailMap} documentation states that a submap of a submap throws an * {@link IllegalArgumentException} if passed a {@code fromKey} less than an earlier {@code * fromKey}. However, this method doesn't throw an exception in that situation, but instead keeps * the original {@code fromKey}. */ @Override public ImmutableSortedMap tailMap(K fromKey) { return tailMap(fromKey, true); } /** * This method returns a {@code ImmutableSortedMap}, consisting of the entries whose keys are * greater than (or equal to, if {@code inclusive}) {@code fromKey}. * *

The {@link SortedMap#tailMap} documentation states that a submap of a submap throws an * {@link IllegalArgumentException} if passed a {@code fromKey} less than an earlier {@code * fromKey}. However, this method doesn't throw an exception in that situation, but instead keeps * the original {@code fromKey}. * * @since 12.0 */ @Override public ImmutableSortedMap tailMap(K fromKey, boolean inclusive) { return getSubMap(keySet.tailIndex(checkNotNull(fromKey), inclusive), size()); } @Override public Entry lowerEntry(K key) { return headMap(key, false).lastEntry(); } @Override public K lowerKey(K key) { return keyOrNull(lowerEntry(key)); } @Override public Entry floorEntry(K key) { return headMap(key, true).lastEntry(); } @Override public K floorKey(K key) { return keyOrNull(floorEntry(key)); } @Override public Entry ceilingEntry(K key) { return tailMap(key, true).firstEntry(); } @Override public K ceilingKey(K key) { return keyOrNull(ceilingEntry(key)); } @Override public Entry higherEntry(K key) { return tailMap(key, false).firstEntry(); } @Override public K higherKey(K key) { return keyOrNull(higherEntry(key)); } @Override public Entry firstEntry() { return isEmpty() ? null : entrySet().asList().get(0); } @Override public Entry lastEntry() { return isEmpty() ? null : entrySet().asList().get(size() - 1); } /** * Guaranteed to throw an exception and leave the map unmodified. * * @throws UnsupportedOperationException always * @deprecated Unsupported operation. */ @CanIgnoreReturnValue @Deprecated @Override public final Entry pollFirstEntry() { throw new UnsupportedOperationException(); } /** * Guaranteed to throw an exception and leave the map unmodified. * * @throws UnsupportedOperationException always * @deprecated Unsupported operation. */ @CanIgnoreReturnValue @Deprecated @Override public final Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ImmutableSortedMap descendingMap() { // TODO(kevinb): the descendingMap is never actually cached at all. Either it should be or the // code below simplified. ImmutableSortedMap result = descendingMap; if (result == null) { if (isEmpty()) { return result = emptyMap(Ordering.from(comparator()).reverse()); } else { return result = new ImmutableSortedMap<>( (RegularImmutableSortedSet) keySet.descendingSet(), valueList.reverse(), this); } } return result; } @Override public ImmutableSortedSet navigableKeySet() { return keySet; } @Override public ImmutableSortedSet descendingKeySet() { return keySet.descendingSet(); } /** * Serialized type for all ImmutableSortedMap instances. It captures the logical contents and they * are reconstructed using public factory methods. This ensures that the implementation types * remain as implementation details. */ private static class SerializedForm extends ImmutableMap.SerializedForm { private final Comparator comparator; @SuppressWarnings("unchecked") SerializedForm(ImmutableSortedMap sortedMap) { super(sortedMap); comparator = (Comparator) sortedMap.comparator(); } @Override Object readResolve() { Builder builder = new Builder<>(comparator); return createMap(builder); } private static final long serialVersionUID = 0; } @Override Object writeReplace() { return new SerializedForm(this); } // This class is never actually serialized directly, but we have to make the // warning go away (and suppressing would suppress for all nested classes too) private static final long serialVersionUID = 0; }