/*
* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
* Copyright (C) 2016-2020 MicroEJ Corp. - EDC compliance and optimizations.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util;
import ej.annotation.Nullable;
/**
* A Red-Black tree based {@link NavigableMap} implementation. The map is sorted according to the {@linkplain Comparable
* natural ordering} of its keys, or by a {@link Comparator} provided at map creation time, depending on which
* constructor is used.
*
*
* This implementation provides guaranteed log(n) time cost for the {@code containsKey}, {@code get}, {@code put} and
* {@code remove} operations. Algorithms are adaptations of those in Cormen, Leiserson, and Rivest's Introduction to
* Algorithms.
*
*
* Note that the ordering maintained by a tree map, like any sorted map, and whether or not an explicit comparator is
* provided, must be consistent with {@code equals} if this sorted map is to correctly implement the
* {@code Map} interface. (See {@code Comparable} or {@code Comparator} for a precise definition of consistent with
* equals.) This is so because the {@code Map} interface is defined in terms of the {@code equals} operation, but a
* sorted map performs all key comparisons using its {@code
* compareTo} (or {@code compare}) method, so two keys that are deemed equal by this method are, from the standpoint of
* the sorted map, equal. The behavior of a sorted map is well-defined even if its ordering is inconsistent
* with {@code equals}; it just fails to obey the general contract of the {@code Map} interface.
*
*
* Note that this implementation is not synchronized. If multiple threads access a map concurrently,
* and at least one of the threads modifies the map structurally, it must be synchronized externally. (A
* structural modification is any operation that adds or deletes one or more mappings; merely changing the value
* associated with an existing key is not a structural modification.) This is typically accomplished by synchronizing on
* some object that naturally encapsulates the map. If no such object exists, the map should be "wrapped" using the
* {@link Collections#synchronizedSortedMap Collections.synchronizedSortedMap} method. This is best done at creation
* time, to prevent accidental unsynchronized access to the map:
*
*
* SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));
*
*
*
* The iterators returned by the {@code iterator} method of the collections returned by all of this class's "collection
* view methods" are fail-fast: if the map is structurally modified at any time after the iterator is created,
* in any way except through the iterator's own {@code remove} method, the iterator will throw a
* {@link ConcurrentModificationException}. Thus, in the face of concurrent modification, the iterator fails quickly and
* cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.
*
*
* Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make
* any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw
* {@code ConcurrentModificationException} on a best-effort basis. Therefore, it would be wrong to write a program that
* depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect
* bugs.
*
*
* All {@code Map.Entry} pairs returned by methods in this class and its views represent snapshots of mappings at the
* time they were produced. They do not support the {@code Entry.setValue} method. (Note however that
* it is possible to change mappings in the associated map using {@code put}.)
*
*
* This class is a member of the Java Collections
* Framework.
*
* @param
* the type of keys maintained by this map
* @param
* the type of mapped values
*
* @author Josh Bloch and Doug Lea
* @see Map
* @see HashMap
* @see Hashtable
* @see Comparable
* @see Comparator
* @see Collection
* @since 1.2
*/
public class TreeMap extends AbstractMap implements NavigableMap, Cloneable, java.io.Serializable {
/**
* The comparator used to maintain order in this tree map, or null if it uses the natural ordering of its keys.
*
* @serial
*/
@Nullable
private final Comparator comparator;
@Nullable
private Collection values;
@Nullable
private transient Entry root;
/**
* The number of entries in the tree
*/
private transient int size = 0;
/**
* The number of structural modifications to the tree.
*/
private transient int modCount = 0;
/**
* Constructs a new, empty tree map, using the natural ordering of its keys. All keys inserted into the map must
* implement the {@link Comparable} interface. Furthermore, all such keys must be mutually comparable:
* {@code k1.compareTo(k2)} must not throw a {@code ClassCastException} for any keys {@code k1} and {@code k2} in
* the map. If the user attempts to put a key into the map that violates this constraint (for example, the user
* attempts to put a string key into a map whose keys are integers), the {@code put(Object key, Object value)} call
* will throw a {@code ClassCastException}.
*/
public TreeMap() {
this.comparator = null;
}
/**
* Constructs a new, empty tree map, ordered according to the given comparator. All keys inserted into the map must
* be mutually comparable by the given comparator: {@code comparator.compare(k1,
* k2)} must not throw a {@code ClassCastException} for any keys {@code k1} and {@code k2} in the map. If the user
* attempts to put a key into the map that violates this constraint, the {@code put(Object
* key, Object value)} call will throw a {@code ClassCastException}.
*
* @param comparator
* the comparator that will be used to order this map. If {@code null}, the {@linkplain Comparable
* natural ordering} of the keys will be used.
*/
public TreeMap(@Nullable Comparator comparator) {
this.comparator = comparator;
}
/**
* Constructs a new tree map containing the same mappings as the given map, ordered according to the natural
* ordering of its keys. All keys inserted into the new map must implement the {@link Comparable} interface.
* Furthermore, all such keys must be mutually comparable: {@code k1.compareTo(k2)} must not throw a
* {@code ClassCastException} for any keys {@code k1} and {@code k2} in the map. This method runs in n*log(n) time.
*
* @param m
* the map whose mappings are to be placed in this map
* @throws ClassCastException
* if the keys in m are not {@link Comparable}, or are not mutually comparable
* @throws NullPointerException
* if the specified map is null
*/
public TreeMap(Map m) {
this.comparator = null;
putAll(m);
}
/**
* Constructs a new tree map containing the same mappings and using the same ordering as the specified sorted map.
* This method runs in linear time.
*
* @param m
* the sorted map whose mappings are to be placed in this map, and whose comparator is to be used to sort
* this map
* @throws NullPointerException
* if the specified map is null
*/
public TreeMap(SortedMap m) {
this.comparator = m.comparator();
buildFromSorted(m.size(), m.entrySet().iterator(), null);
}
// Query Operations
/**
* Returns the number of key-value mappings in this map.
*
* @return the number of key-value mappings in this map
*/
@Override
public int size() {
return this.size;
}
/**
* Returns {@code true} if this map contains a mapping for the specified key.
*
* @param key
* key whose presence in this map is to be tested
* @return {@code true} if this map contains a mapping for the specified key
* @throws ClassCastException
* if the specified key cannot be compared with the keys currently in the map
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
*/
@Override
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
/**
* Returns {@code true} if this map maps one or more keys to the specified value. More formally, returns
* {@code true} if and only if this map contains at least one mapping to a value {@code v} such that
* {@code (value==null ? v==null : value.equals(v))}. This operation will probably require time linear in the map
* size for most implementations.
*
* @param value
* value whose presence in this map is to be tested
* @return {@code true} if a mapping to {@code value} exists; {@code false} otherwise
* @since 1.2
*/
@Override
public boolean containsValue(Object value) {
for (Entry e = getFirstEntry(); e != null; e = successor(e)) {
if (valEquals(value, e.value)) {
return true;
}
}
return false;
}
/**
* Returns the value to which the specified key is mapped, or {@code null} if this map contains no mapping for the
* key.
*
*
* More formally, if this map contains a mapping from a key {@code k} to a value {@code v} such that {@code key}
* compares equal to {@code k} according to the map's ordering, then this method returns {@code v}; otherwise it
* returns {@code null}. (There can be at most one such mapping.)
*
*
* A return value of {@code null} does not necessarily indicate that the map contains no mapping for the
* key; it's also possible that the map explicitly maps the key to {@code null}. The {@link #containsKey
* containsKey} operation may be used to distinguish these two cases.
*
* @throws ClassCastException
* if the specified key cannot be compared with the keys currently in the map
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
*/
@Override
@Nullable
public V get(Object key) {
Entry p = getEntry(key);
return (p == null ? null : p.value);
}
@Override
@Nullable
public Comparator comparator() {
return this.comparator;
}
/**
* @throws NoSuchElementException
* {@inheritDoc}
*/
@Override
public K firstKey() {
return key(getFirstEntry());
}
/**
* @throws NoSuchElementException
* {@inheritDoc}
*/
@Override
public K lastKey() {
return key(getLastEntry());
}
/**
* Copies all of the mappings from the specified map to this map. These mappings replace any mappings that this map
* had for any of the keys currently in the specified map.
*
* @param map
* mappings to be stored in this map
* @throws ClassCastException
* if the class of a key or value in the specified map prevents it from being stored in this map
* @throws NullPointerException
* if the specified map is null or the specified map contains a null key and this map does not permit
* null keys
*/
@Override
public void putAll(Map map) {
int mapSize = map.size();
if (this.size == 0 && mapSize != 0 && map instanceof SortedMap) {
Comparator c = ((SortedMap) map).comparator();
if (c == this.comparator || (c != null && c.equals(this.comparator))) {
++this.modCount;
buildFromSorted(mapSize, map.entrySet().iterator(), null);
return;
}
}
super.putAll(map);
}
/**
* Returns this map's entry for the given key, or {@code null} if the map does not contain an entry for the key.
*
* @return this map's entry for the given key, or {@code null} if the map does not contain an entry for the key
* @throws ClassCastException
* if the specified key cannot be compared with the keys currently in the map
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
*/
@Nullable
final Entry getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (this.comparator != null) {
return getEntryUsingComparator(key);
}
if (key == null) {
throw new NullPointerException();
}
@SuppressWarnings("unchecked")
Comparable k = (Comparable) key;
Entry p = this.root;
while (p != null) {
int cmp = k.compareTo(p.key);
if (cmp < 0) {
p = p.left;
} else if (cmp > 0) {
p = p.right;
} else {
return p;
}
}
return null;
}
/**
* Version of getEntry using comparator. Split off from getEntry for performance. (This is not worth doing for most
* methods, that are less dependent on comparator performance, but is worthwhile here.)
*/
@Nullable
final Entry getEntryUsingComparator(Object key) {
@SuppressWarnings("unchecked")
K k = (K) key;
Comparator cpr = this.comparator;
if (cpr != null) {
Entry p = this.root;
while (p != null) {
int cmp = cpr.compare(k, p.key);
if (cmp < 0) {
p = p.left;
} else if (cmp > 0) {
p = p.right;
} else {
return p;
}
}
}
return null;
}
/**
* Gets the entry corresponding to the specified key; if no such entry exists, returns the entry for the least key
* greater than the specified key; if no such entry exists (i.e., the greatest key in the Tree is less than the
* specified key), returns {@code null}.
*/
@Nullable
final Entry getCeilingEntry(K key) {
Entry p = this.root;
while (p != null) {
int cmp = compare(key, p.key);
if (cmp < 0) {
if (p.left != null) {
p = p.left;
} else {
return p;
}
} else if (cmp > 0) {
if (p.right != null) {
p = p.right;
} else {
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.right) {
ch = parent;
parent = parent.parent;
}
return parent;
}
} else {
return p;
}
}
return null;
}
/**
* Gets the entry corresponding to the specified key; if no such entry exists, returns the entry for the greatest
* key less than the specified key; if no such entry exists, returns {@code null}.
*/
@Nullable
final Entry getFloorEntry(K key) {
Entry p = this.root;
while (p != null) {
int cmp = compare(key, p.key);
if (cmp > 0) {
if (p.right != null) {
p = p.right;
} else {
return p;
}
} else if (cmp < 0) {
if (p.left != null) {
p = p.left;
} else {
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.left) {
ch = parent;
parent = parent.parent;
}
return parent;
}
} else {
return p;
}
}
return null;
}
/**
* Gets the entry for the least key greater than the specified key; if no such entry exists, returns the entry for
* the least key greater than the specified key; if no such entry exists returns {@code null}.
*/
@Nullable
final Entry getHigherEntry(K key) {
Entry p = this.root;
while (p != null) {
int cmp = compare(key, p.key);
if (cmp < 0) {
if (p.left != null) {
p = p.left;
} else {
return p;
}
} else {
if (p.right != null) {
p = p.right;
} else {
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.right) {
ch = parent;
parent = parent.parent;
}
return parent;
}
}
}
return null;
}
/**
* Returns the entry for the greatest key less than the specified key; if no such entry exists (i.e., the least key
* in the Tree is greater than the specified key), returns {@code null}.
*/
@Nullable
final Entry getLowerEntry(K key) {
Entry p = this.root;
while (p != null) {
int cmp = compare(key, p.key);
if (cmp > 0) {
if (p.right != null) {
p = p.right;
} else {
return p;
}
} else {
if (p.left != null) {
p = p.left;
} else {
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.left) {
ch = parent;
parent = parent.parent;
}
return parent;
}
}
}
return null;
}
/**
* Associates the specified value with the specified key in this map. If the map previously contained a mapping for
* the key, the old value is replaced.
*
* @param key
* key with which the specified value is to be associated
* @param value
* value to be associated with the specified key
*
* @return the previous value associated with {@code key}, or {@code null} if there was no mapping for {@code key}.
* (A {@code null} return can also indicate that the map previously associated {@code null} with {@code key}
* .)
* @throws ClassCastException
* if the specified key cannot be compared with the keys currently in the map
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
*/
@Override
@Nullable
public V put(K key, V value) {
Entry t = this.root;
if (t == null) {
compare(key, key); // type (and possibly null) check
this.root = new Entry<>(key, value, null);
this.size = 1;
this.modCount++;
return null;
}
int cmp;
Entry parent;
// split comparator and comparable paths
Comparator cpr = this.comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0) {
t = t.left;
} else if (cmp > 0) {
t = t.right;
} else {
return t.setValue(value);
}
} while (t != null);
} else {
if (key == null) {
throw new NullPointerException();
}
@SuppressWarnings("unchecked")
Comparable k = (Comparable) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0) {
t = t.left;
} else if (cmp > 0) {
t = t.right;
} else {
return t.setValue(value);
}
} while (t != null);
}
Entry e = new Entry<>(key, value, parent);
if (cmp < 0) {
parent.left = e;
} else {
parent.right = e;
}
fixAfterInsertion(e);
this.size++;
this.modCount++;
return null;
}
/**
* Removes the mapping for this key from this TreeMap if present.
*
* @param key
* key for which mapping should be removed
* @return the previous value associated with {@code key}, or {@code null} if there was no mapping for {@code key}.
* (A {@code null} return can also indicate that the map previously associated {@code null} with {@code key}
* .)
* @throws ClassCastException
* if the specified key cannot be compared with the keys currently in the map
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
*/
@Override
@Nullable
public V remove(Object key) {
Entry p = getEntry(key);
if (p == null) {
return null;
}
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
/**
* Removes all of the mappings from this map. The map will be empty after this call returns.
*/
@Override
public void clear() {
this.modCount++;
this.size = 0;
this.root = null;
}
/**
* Returns a shallow copy of this {@code TreeMap} instance. (The keys and values themselves are not cloned.)
*
* @return a shallow copy of this map
*/
@Override
public Object clone() {
TreeMap clone;
try {
clone = (TreeMap) super.clone();
} catch (CloneNotSupportedException e) {
Error error = new InternalError();
error.initCause(e);
throw error;
}
// Put clone into "virgin" state (except for comparator)
clone.root = null;
clone.size = 0;
clone.modCount = 0;
clone.entrySet = null;
clone.navigableKeySet = null;
clone.descendingMap = null;
// Initialize clone with our mappings
clone.buildFromSorted(this.size, entrySet().iterator(), null);
return clone;
}
// NavigableMap API methods
/**
* @since 1.6
*/
@Override
@Nullable
public Map.Entry firstEntry() {
return exportEntry(getFirstEntry());
}
/**
* @since 1.6
*/
@Override
@Nullable
public Map.Entry lastEntry() {
return exportEntry(getLastEntry());
}
/**
* @since 1.6
*/
@Override
@Nullable
public Map.Entry pollFirstEntry() {
Entry p = getFirstEntry();
Map.Entry result = exportEntry(p);
if (p != null) {
deleteEntry(p);
}
return result;
}
/**
* @since 1.6
*/
@Override
@Nullable
public Map.Entry pollLastEntry() {
Entry p = getLastEntry();
Map.Entry result = exportEntry(p);
if (p != null) {
deleteEntry(p);
}
return result;
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public Map.Entry lowerEntry(K key) {
return exportEntry(getLowerEntry(key));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public K lowerKey(K key) {
return keyOrNull(getLowerEntry(key));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public Map.Entry floorEntry(K key) {
return exportEntry(getFloorEntry(key));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public K floorKey(K key) {
return keyOrNull(getFloorEntry(key));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public Map.Entry ceilingEntry(K key) {
return exportEntry(getCeilingEntry(key));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public K ceilingKey(K key) {
return keyOrNull(getCeilingEntry(key));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public Map.Entry higherEntry(K key) {
return exportEntry(getHigherEntry(key));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if the specified key is null and this map uses natural ordering, or its comparator does not permit
* null keys
* @since 1.6
*/
@Override
@Nullable
public K higherKey(K key) {
return keyOrNull(getHigherEntry(key));
}
// Views
/**
* Fields initialized to contain an instance of the entry set view the first time this view is requested. Views are
* stateless, so there's no reason to create more than one.
*/
@Nullable
private transient EntrySet entrySet;
@Nullable
private transient KeySet navigableKeySet;
@Nullable
private transient NavigableMap descendingMap;
/**
* Returns a {@link Set} view of the keys contained in this map.
*
*
* The set's iterator returns the keys in ascending order.
*
*
* The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is
* modified while an iteration over the set is in progress (except through the iterator's own {@code remove}
* operation), the results of the iteration are undefined. The set supports element removal, which removes the
* corresponding mapping from the map, via the {@code Iterator.remove}, {@code Set.remove}, {@code removeAll},
* {@code retainAll}, and {@code clear} operations. It does not support the {@code add} or {@code addAll}
* operations.
*/
@Override
public Set keySet() {
return navigableKeySet();
}
/**
* @since 1.6
*/
@Override
public NavigableSet navigableKeySet() {
KeySet nks = this.navigableKeySet;
return (nks != null) ? nks : (this.navigableKeySet = new KeySet<>(this));
}
/**
* @since 1.6
*/
@Override
public NavigableSet descendingKeySet() {
return descendingMap().navigableKeySet();
}
/**
* Returns a {@link Collection} view of the values contained in this map.
*
*
* The collection's iterator returns the values in ascending order of the corresponding keys.
*
*
* The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If
* the map is modified while an iteration over the collection is in progress (except through the iterator's own
* {@code remove} operation), the results of the iteration are undefined. The collection supports element removal,
* which removes the corresponding mapping from the map, via the {@code Iterator.remove}, {@code Collection.remove},
* {@code removeAll}, {@code retainAll} and {@code clear} operations. It does not support the {@code add} or
* {@code addAll} operations.
*/
@Override
public Collection values() {
Collection vs = this.values;
return (vs != null) ? vs : (this.values = new Values());
}
/**
* Returns a {@link Set} view of the mappings contained in this map.
*
*
* The set's iterator returns the entries in ascending key order.
*
*
* The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is
* modified while an iteration over the set is in progress (except through the iterator's own {@code remove}
* operation, or through the {@code setValue} operation on a map entry returned by the iterator) the results of the
* iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map,
* via the {@code Iterator.remove}, {@code Set.remove}, {@code removeAll}, {@code retainAll} and {@code clear}
* operations. It does not support the {@code add} or {@code addAll} operations.
*/
@Override
public Set> entrySet() {
EntrySet es = this.entrySet;
return (es != null) ? es : (this.entrySet = new EntrySet());
}
/**
* @since 1.6
*/
@Override
public NavigableMap descendingMap() {
NavigableMap km = this.descendingMap;
return (km != null) ? km
: (this.descendingMap = new DescendingSubMap<>(this, true, null, true, true, null, true));
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if {@code fromKey} or {@code toKey} is null and this map uses natural ordering, or its comparator
* does not permit null keys
* @throws IllegalArgumentException
* {@inheritDoc}
* @since 1.6
*/
@Override
public NavigableMap subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
return new AscendingSubMap<>(this, false, fromKey, fromInclusive, false, toKey, toInclusive);
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if {@code toKey} is null and this map uses natural ordering, or its comparator does not permit null
* keys
* @throws IllegalArgumentException
* {@inheritDoc}
* @since 1.6
*/
@Override
public NavigableMap headMap(K toKey, boolean inclusive) {
return new AscendingSubMap<>(this, true, null, true, false, toKey, inclusive);
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if {@code fromKey} is null and this map uses natural ordering, or its comparator does not permit null
* keys
* @throws IllegalArgumentException
* {@inheritDoc}
* @since 1.6
*/
@Override
public NavigableMap tailMap(K fromKey, boolean inclusive) {
return new AscendingSubMap<>(this, false, fromKey, inclusive, true, null, true);
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if {@code fromKey} or {@code toKey} is null and this map uses natural ordering, or its comparator
* does not permit null keys
* @throws IllegalArgumentException
* {@inheritDoc}
*/
@Override
public SortedMap subMap(K fromKey, K toKey) {
return subMap(fromKey, true, toKey, false);
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if {@code toKey} is null and this map uses natural ordering, or its comparator does not permit null
* keys
* @throws IllegalArgumentException
* {@inheritDoc}
*/
@Override
public SortedMap headMap(K toKey) {
return headMap(toKey, false);
}
/**
* @throws ClassCastException
* {@inheritDoc}
* @throws NullPointerException
* if {@code fromKey} is null and this map uses natural ordering, or its comparator does not permit null
* keys
* @throws IllegalArgumentException
* {@inheritDoc}
*/
@Override
public SortedMap tailMap(K fromKey) {
return tailMap(fromKey, true);
}
// View class support
class Values extends AbstractCollection {
@Override
public Iterator iterator() {
return new ValueIterator(getFirstEntry());
}
@Override
public int size() {
return TreeMap.this.size();
}
@Override
public boolean contains(Object o) {
return TreeMap.this.containsValue(o);
}
@Override
public boolean remove(Object o) {
for (Entry e = getFirstEntry(); e != null; e = successor(e)) {
if (valEquals(e.getValue(), o)) {
deleteEntry(e);
return true;
}
}
return false;
}
@Override
public void clear() {
TreeMap.this.clear();
}
}
class EntrySet extends AbstractSet> {
@Override
public Iterator> iterator() {
return new EntryIterator(getFirstEntry());
}
@Override
public boolean contains(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object value = entry.getValue();
Entry p = getEntry(entry.getKey());
return p != null && valEquals(p.getValue(), value);
}
@Override
public boolean remove(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object value = entry.getValue();
Entry p = getEntry(entry.getKey());
if (p != null && valEquals(p.getValue(), value)) {
deleteEntry(p);
return true;
}
return false;
}
@Override
public int size() {
return TreeMap.this.size();
}
@Override
public void clear() {
TreeMap.this.clear();
}
}
/*
* Unlike Values and EntrySet, the KeySet class is static, delegating to a NavigableMap to allow use by SubMaps,
* which outweighs the ugliness of needing type-tests for the following Iterator methods that are defined
* appropriately in main versus submap classes.
*/
Iterator keyIterator() {
return new KeyIterator(getFirstEntry());
}
Iterator descendingKeyIterator() {
return new DescendingKeyIterator(getLastEntry());
}
static final class KeySet extends AbstractSet implements NavigableSet {
private final NavigableMap m;
KeySet(NavigableMap map) {
this.m = map;
}
@Override
public Iterator iterator() {
if (this.m instanceof TreeMap) {
return ((TreeMap) this.m).keyIterator();
} else {
return ((TreeMap.NavigableSubMap) this.m).keyIterator();
}
}
@Override
public Iterator descendingIterator() {
if (this.m instanceof TreeMap) {
return ((TreeMap) this.m).descendingKeyIterator();
} else {
return ((TreeMap.NavigableSubMap) this.m).descendingKeyIterator();
}
}
@Override
public int size() {
return this.m.size();
}
@Override
public boolean isEmpty() {
return this.m.isEmpty();
}
@Override
public boolean contains(Object o) {
return this.m.containsKey(o);
}
@Override
public void clear() {
this.m.clear();
}
@Override
@Nullable
public E lower(E e) {
return this.m.lowerKey(e);
}
@Override
@Nullable
public E floor(E e) {
return this.m.floorKey(e);
}
@Override
@Nullable
public E ceiling(E e) {
return this.m.ceilingKey(e);
}
@Override
@Nullable
public E higher(E e) {
return this.m.higherKey(e);
}
@Override
public E first() {
return this.m.firstKey();
}
@Override
public E last() {
return this.m.lastKey();
}
@Override
@Nullable
public Comparator comparator() {
return this.m.comparator();
}
@Override
@Nullable
public E pollFirst() {
Map.Entry e = this.m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
@Override
@Nullable
public E pollLast() {
Map.Entry e = this.m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
@Override
public boolean remove(Object o) {
int oldSize = size();
this.m.remove(o);
return size() != oldSize;
}
@Override
public NavigableSet subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
return new KeySet<>(this.m.subMap(fromElement, fromInclusive, toElement, toInclusive));
}
@Override
public NavigableSet headSet(E toElement, boolean inclusive) {
return new KeySet<>(this.m.headMap(toElement, inclusive));
}
@Override
public NavigableSet tailSet(E fromElement, boolean inclusive) {
return new KeySet<>(this.m.tailMap(fromElement, inclusive));
}
@Override
public SortedSet subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
@Override
public SortedSet headSet(E toElement) {
return headSet(toElement, false);
}
@Override
public SortedSet tailSet(E fromElement) {
return tailSet(fromElement, true);
}
@Override
public NavigableSet descendingSet() {
return new KeySet<>(this.m.descendingMap());
}
}
/**
* Base class for TreeMap Iterators
*/
abstract class PrivateEntryIterator implements Iterator {
@Nullable
Entry next;
@Nullable
Entry lastReturned;
int expectedModCount;
PrivateEntryIterator(@Nullable Entry first) {
this.expectedModCount = TreeMap.this.modCount;
this.lastReturned = null;
this.next = first;
}
@Override
public final boolean hasNext() {
return this.next != null;
}
final Entry nextEntry() {
Entry e = this.next;
if (e == null) {
throw new NoSuchElementException();
}
if (TreeMap.this.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
this.next = successor(e);
this.lastReturned = e;
return e;
}
final Entry prevEntry() {
Entry e = this.next;
if (e == null) {
throw new NoSuchElementException();
}
if (TreeMap.this.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
this.next = predecessor(e);
this.lastReturned = e;
return e;
}
@Override
public void remove() {
if (this.lastReturned == null) {
throw new IllegalStateException();
}
if (TreeMap.this.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
// deleted entries are replaced by their successors
if (this.lastReturned.left != null && this.lastReturned.right != null) {
this.next = this.lastReturned;
}
deleteEntry(this.lastReturned);
this.expectedModCount = TreeMap.this.modCount;
this.lastReturned = null;
}
}
final class EntryIterator extends PrivateEntryIterator> {
EntryIterator(@Nullable Entry first) {
super(first);
}
@Override
public Map.Entry next() {
return nextEntry();
}
}
final class ValueIterator extends PrivateEntryIterator {
ValueIterator(@Nullable Entry first) {
super(first);
}
@Override
public V next() {
return nextEntry().value;
}
}
final class KeyIterator extends PrivateEntryIterator {
KeyIterator(@Nullable Entry first) {
super(first);
}
@Override
public K next() {
return nextEntry().key;
}
}
final class DescendingKeyIterator extends PrivateEntryIterator {
DescendingKeyIterator(@Nullable Entry first) {
super(first);
}
@Override
public K next() {
return prevEntry().key;
}
@Override
public void remove() {
if (this.lastReturned == null) {
throw new IllegalStateException();
}
if (TreeMap.this.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
deleteEntry(this.lastReturned);
this.lastReturned = null;
this.expectedModCount = TreeMap.this.modCount;
}
}
// Little utilities
/**
* Compares two keys using the correct comparison method for this TreeMap.
*/
@SuppressWarnings("unchecked")
final int compare(Object k1, Object k2) {
return this.comparator == null ? ((Comparable) k1).compareTo((K) k2)
: this.comparator.compare((K) k1, (K) k2);
}
/**
* Test two values for equality. Differs from o1.equals(o2) only in that it copes with {@code null} o1 properly.
*/
static final boolean valEquals(@Nullable Object o1, Object o2) {
return (o1 == null ? o2 == null : o1.equals(o2));
}
/**
* Return SimpleImmutableEntry for entry, or null if null
*/
@Nullable
static Map.Entry exportEntry(@Nullable TreeMap.Entry e) {
return (e == null) ? null : new AbstractMap.SimpleImmutableEntry<>(e);
}
/**
* Return key for entry, or null if null
*/
@Nullable
static K keyOrNull(@Nullable TreeMap.Entry e) {
return (e == null) ? null : e.key;
}
/**
* Returns the key corresponding to the specified Entry.
*
* @throws NoSuchElementException
* if the Entry is null
*/
static K key(Entry e) {
if (e == null) {
throw new NoSuchElementException();
}
return e.key;
}
// SubMaps
/**
* Dummy value serving as unmatchable fence key for unbounded SubMapIterators
*/
private static final Object UNBOUNDED = new Object();
/**
* @serial include
*/
abstract static class NavigableSubMap extends AbstractMap
implements NavigableMap, java.io.Serializable {
private static final long serialVersionUID = -2102997345730753016L;
/**
* The backing map.
*/
final TreeMap m;
/**
* Endpoints are represented as triples (fromStart, lo, loInclusive) and (toEnd, hi, hiInclusive). If fromStart
* is true, then the low (absolute) bound is the start of the backing map, and the other values are ignored.
* Otherwise, if loInclusive is true, lo is the inclusive bound, else lo is the exclusive bound. Similarly for
* the upper bound.
*/
@Nullable
final K lo, hi;
final boolean fromStart, toEnd;
final boolean loInclusive, hiInclusive;
NavigableSubMap(TreeMap m, boolean fromStart, @Nullable K lo, boolean loInclusive, boolean toEnd,
@Nullable K hi, boolean hiInclusive) {
if (!fromStart && !toEnd) {
if (m.compare(lo, hi) > 0) {
throw new IllegalArgumentException("fromKey > toKey");
}
} else {
if (!fromStart) {
m.compare(lo, lo);
}
if (!toEnd) {
m.compare(hi, hi);
}
}
this.m = m;
this.fromStart = fromStart;
this.lo = lo;
this.loInclusive = loInclusive;
this.toEnd = toEnd;
this.hi = hi;
this.hiInclusive = hiInclusive;
}
// internal utilities
final boolean tooLow(Object key) {
if (!this.fromStart) {
int c = this.m.compare(key, this.lo);
if (c < 0 || (c == 0 && !this.loInclusive)) {
return true;
}
}
return false;
}
final boolean tooHigh(Object key) {
if (!this.toEnd) {
int c = this.m.compare(key, this.hi);
if (c > 0 || (c == 0 && !this.hiInclusive)) {
return true;
}
}
return false;
}
final boolean inRange(Object key) {
return !tooLow(key) && !tooHigh(key);
}
final boolean inClosedRange(Object key) {
return (this.fromStart || this.m.compare(key, this.lo) >= 0)
&& (this.toEnd || this.m.compare(this.hi, key) >= 0);
}
final boolean inRange(Object key, boolean inclusive) {
return inclusive ? inRange(key) : inClosedRange(key);
}
/*
* Absolute versions of relation operations. Subclasses map to these using like-named "sub" versions that invert
* senses for descending maps
*/
@Nullable
final TreeMap.Entry absLowest() {
TreeMap.Entry e = (this.fromStart ? this.m.getFirstEntry()
: (this.loInclusive ? this.m.getCeilingEntry(this.lo) : this.m.getHigherEntry(this.lo)));
return (e == null || tooHigh(e.key)) ? null : e;
}
@Nullable
final TreeMap.Entry absHighest() {
TreeMap.Entry e = (this.toEnd ? this.m.getLastEntry()
: (this.hiInclusive ? this.m.getFloorEntry(this.hi) : this.m.getLowerEntry(this.hi)));
return (e == null || tooLow(e.key)) ? null : e;
}
@Nullable
final TreeMap.Entry absCeiling(K key) {
if (tooLow(key)) {
return absLowest();
}
TreeMap.Entry e = this.m.getCeilingEntry(key);
return (e == null || tooHigh(e.key)) ? null : e;
}
@Nullable
final TreeMap.Entry absHigher(K key) {
if (tooLow(key)) {
return absLowest();
}
TreeMap.Entry e = this.m.getHigherEntry(key);
return (e == null || tooHigh(e.key)) ? null : e;
}
@Nullable
final TreeMap.Entry absFloor(K key) {
if (tooHigh(key)) {
return absHighest();
}
TreeMap.Entry e = this.m.getFloorEntry(key);
return (e == null || tooLow(e.key)) ? null : e;
}
@Nullable
final TreeMap.Entry absLower(K key) {
if (tooHigh(key)) {
return absHighest();
}
TreeMap.Entry e = this.m.getLowerEntry(key);
return (e == null || tooLow(e.key)) ? null : e;
}
/** Returns the absolute high fence for ascending traversal */
@Nullable
final TreeMap.Entry absHighFence() {
return (this.toEnd ? null
: (this.hiInclusive ? this.m.getHigherEntry(this.hi) : this.m.getCeilingEntry(this.hi)));
}
/** Return the absolute low fence for descending traversal */
@Nullable
final TreeMap.Entry absLowFence() {
return (this.fromStart ? null
: (this.loInclusive ? this.m.getLowerEntry(this.lo) : this.m.getFloorEntry(this.lo)));
}
// Abstract methods defined in ascending vs descending classes
// These relay to the appropriate absolute versions
@Nullable
abstract TreeMap.Entry subLowest();
@Nullable
abstract TreeMap.Entry subHighest();
@Nullable
abstract TreeMap.Entry subCeiling(K key);
@Nullable
abstract TreeMap.Entry subHigher(K key);
@Nullable
abstract TreeMap.Entry subFloor(K key);
@Nullable
abstract TreeMap.Entry subLower(K key);
/** Returns ascending iterator from the perspective of this submap */
abstract Iterator keyIterator();
/** Returns descending iterator from the perspective of this submap */
abstract Iterator descendingKeyIterator();
// public methods
@Override
public boolean isEmpty() {
return (this.fromStart && this.toEnd) ? this.m.isEmpty() : entrySet().isEmpty();
}
@Override
public int size() {
return (this.fromStart && this.toEnd) ? this.m.size() : entrySet().size();
}
@Override
public final boolean containsKey(Object key) {
return inRange(key) && this.m.containsKey(key);
}
@Override
@Nullable
public final V put(K key, V value) {
if (!inRange(key)) {
throw new IllegalArgumentException("key out of range");
}
return this.m.put(key, value);
}
@Override
@Nullable
public final V get(Object key) {
return !inRange(key) ? null : this.m.get(key);
}
@Override
@Nullable
public final V remove(Object key) {
return !inRange(key) ? null : this.m.remove(key);
}
@Override
@Nullable
public final Map.Entry ceilingEntry(K key) {
return exportEntry(subCeiling(key));
}
@Override
@Nullable
public final K ceilingKey(K key) {
return keyOrNull(subCeiling(key));
}
@Override
@Nullable
public final Map.Entry higherEntry(K key) {
return exportEntry(subHigher(key));
}
@Override
@Nullable
public final K higherKey(K key) {
return keyOrNull(subHigher(key));
}
@Override
@Nullable
public final Map.Entry floorEntry(K key) {
return exportEntry(subFloor(key));
}
@Override
@Nullable
public final K floorKey(K key) {
return keyOrNull(subFloor(key));
}
@Override
@Nullable
public final Map.Entry lowerEntry(K key) {
return exportEntry(subLower(key));
}
@Override
@Nullable
public final K lowerKey(K key) {
return keyOrNull(subLower(key));
}
@Override
public final K firstKey() {
return key(subLowest());
}
@Override
public final K lastKey() {
return key(subHighest());
}
@Override
@Nullable
public final Map.Entry firstEntry() {
return exportEntry(subLowest());
}
@Override
@Nullable
public final Map.Entry lastEntry() {
return exportEntry(subHighest());
}
@Override
@Nullable
public final Map.Entry pollFirstEntry() {
TreeMap.Entry e = subLowest();
Map.Entry result = exportEntry(e);
if (e != null) {
this.m.deleteEntry(e);
}
return result;
}
@Override
@Nullable
public final Map.Entry pollLastEntry() {
TreeMap.Entry e = subHighest();
Map.Entry result = exportEntry(e);
if (e != null) {
this.m.deleteEntry(e);
}
return result;
}
// Views
@Nullable
transient NavigableMap descendingMapView;
@Nullable
transient EntrySetView entrySetView;
@Nullable
transient KeySet navigableKeySetView;
@Override
public final NavigableSet navigableKeySet() {
KeySet nksv = this.navigableKeySetView;
return (nksv != null) ? nksv : (this.navigableKeySetView = new TreeMap.KeySet<>(this));
}
@Override
public final Set keySet() {
return navigableKeySet();
}
@Override
public NavigableSet descendingKeySet() {
return descendingMap().navigableKeySet();
}
@Override
public final SortedMap subMap(K fromKey, K toKey) {
return subMap(fromKey, true, toKey, false);
}
@Override
public final SortedMap headMap(K toKey) {
return headMap(toKey, false);
}
@Override
public final SortedMap tailMap(K fromKey) {
return tailMap(fromKey, true);
}
// View classes
abstract class EntrySetView extends AbstractSet> {
private transient int size = -1, sizeModCount;
@Override
public int size() {
if (NavigableSubMap.this.fromStart && NavigableSubMap.this.toEnd) {
return NavigableSubMap.this.m.size();
}
if (this.size == -1 || this.sizeModCount != NavigableSubMap.this.m.modCount) {
this.sizeModCount = NavigableSubMap.this.m.modCount;
this.size = 0;
Iterator i = iterator();
while (i.hasNext()) {
this.size++;
i.next();
}
}
return this.size;
}
@Override
public boolean isEmpty() {
TreeMap.Entry n = absLowest();
return n == null || tooHigh(n.key);
}
@Override
public boolean contains(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object key = entry.getKey();
if (!inRange(key)) {
return false;
}
TreeMap.Entry node = NavigableSubMap.this.m.getEntry(key);
return node != null && valEquals(node.getValue(), entry.getValue());
}
@Override
public boolean remove(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object key = entry.getKey();
if (!inRange(key)) {
return false;
}
TreeMap.Entry node = NavigableSubMap.this.m.getEntry(key);
if (node != null && valEquals(node.getValue(), entry.getValue())) {
NavigableSubMap.this.m.deleteEntry(node);
return true;
}
return false;
}
}
/**
* Iterators for SubMaps
*/
abstract class SubMapIterator implements Iterator {
@Nullable
TreeMap.Entry lastReturned;
@Nullable
TreeMap.Entry next;
final Object fenceKey;
int expectedModCount;
SubMapIterator(@Nullable TreeMap.Entry first, @Nullable TreeMap.Entry fence) {
this.expectedModCount = NavigableSubMap.this.m.modCount;
this.lastReturned = null;
this.next = first;
this.fenceKey = fence == null ? UNBOUNDED : fence.key;
}
@Override
public final boolean hasNext() {
return this.next != null && this.next.key != this.fenceKey;
}
final TreeMap.Entry nextEntry() {
TreeMap.Entry e = this.next;
if (e == null || e.key == this.fenceKey) {
throw new NoSuchElementException();
}
if (NavigableSubMap.this.m.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
this.next = successor(e);
this.lastReturned = e;
return e;
}
final TreeMap.Entry prevEntry() {
TreeMap.Entry e = this.next;
if (e == null || e.key == this.fenceKey) {
throw new NoSuchElementException();
}
if (NavigableSubMap.this.m.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
this.next = predecessor(e);
this.lastReturned = e;
return e;
}
final void removeAscending() {
if (this.lastReturned == null) {
throw new IllegalStateException();
}
if (NavigableSubMap.this.m.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
// deleted entries are replaced by their successors
if (this.lastReturned.left != null && this.lastReturned.right != null) {
this.next = this.lastReturned;
}
NavigableSubMap.this.m.deleteEntry(this.lastReturned);
this.lastReturned = null;
this.expectedModCount = NavigableSubMap.this.m.modCount;
}
final void removeDescending() {
if (this.lastReturned == null) {
throw new IllegalStateException();
}
if (NavigableSubMap.this.m.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
NavigableSubMap.this.m.deleteEntry(this.lastReturned);
this.lastReturned = null;
this.expectedModCount = NavigableSubMap.this.m.modCount;
}
}
final class SubMapEntryIterator extends SubMapIterator> {
SubMapEntryIterator(@Nullable TreeMap.Entry first, @Nullable TreeMap.Entry fence) {
super(first, fence);
}
@Override
public Map.Entry next() {
return nextEntry();
}
@Override
public void remove() {
removeAscending();
}
}
final class DescendingSubMapEntryIterator extends SubMapIterator> {
DescendingSubMapEntryIterator(@Nullable TreeMap.Entry last, @Nullable TreeMap.Entry fence) {
super(last, fence);
}
@Override
public Map.Entry next() {
return prevEntry();
}
@Override
public void remove() {
removeDescending();
}
}
// Implement minimal Spliterator as KeySpliterator backup
final class SubMapKeyIterator extends SubMapIterator {
SubMapKeyIterator(@Nullable TreeMap.Entry first, @Nullable TreeMap.Entry fence) {
super(first, fence);
}
@Override
public K next() {
return nextEntry().key;
}
@Override
public void remove() {
removeAscending();
}
public long estimateSize() {
return Long.MAX_VALUE;
}
@Nullable
public final Comparator getComparator() {
return NavigableSubMap.this.comparator();
}
}
final class DescendingSubMapKeyIterator extends SubMapIterator {
DescendingSubMapKeyIterator(@Nullable TreeMap.Entry last, @Nullable TreeMap.Entry fence) {
super(last, fence);
}
@Override
public K next() {
return prevEntry().key;
}
@Override
public void remove() {
removeDescending();
}
public long estimateSize() {
return Long.MAX_VALUE;
}
}
}
/**
* @serial include
*/
static final class AscendingSubMap extends NavigableSubMap {
private static final long serialVersionUID = 912986545866124060L;
AscendingSubMap(TreeMap m, boolean fromStart, @Nullable K lo, boolean loInclusive, boolean toEnd,
@Nullable K hi, boolean hiInclusive) {
super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
}
@Override
@Nullable
public Comparator comparator() {
return this.m.comparator();
}
@Override
public NavigableMap subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
if (!inRange(fromKey, fromInclusive)) {
throw new IllegalArgumentException("fromKey out of range");
}
if (!inRange(toKey, toInclusive)) {
throw new IllegalArgumentException("toKey out of range");
}
return new AscendingSubMap<>(this.m, false, fromKey, fromInclusive, false, toKey, toInclusive);
}
@Override
public NavigableMap headMap(K toKey, boolean inclusive) {
if (!inRange(toKey, inclusive)) {
throw new IllegalArgumentException("toKey out of range");
}
return new AscendingSubMap<>(this.m, this.fromStart, this.lo, this.loInclusive, false, toKey, inclusive);
}
@Override
public NavigableMap tailMap(K fromKey, boolean inclusive) {
if (!inRange(fromKey, inclusive)) {
throw new IllegalArgumentException("fromKey out of range");
}
return new AscendingSubMap<>(this.m, false, fromKey, inclusive, this.toEnd, this.hi, this.hiInclusive);
}
@Override
public NavigableMap descendingMap() {
NavigableMap mv = this.descendingMapView;
return (mv != null) ? mv
: (this.descendingMapView = new DescendingSubMap<>(this.m, this.fromStart, this.lo,
this.loInclusive, this.toEnd, this.hi, this.hiInclusive));
}
@Override
Iterator keyIterator() {
return new SubMapKeyIterator(absLowest(), absHighFence());
}
@Override
Iterator descendingKeyIterator() {
return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
}
final class AscendingEntrySetView extends EntrySetView {
@Override
public Iterator> iterator() {
return new SubMapEntryIterator(absLowest(), absHighFence());
}
}
@Override
public Set> entrySet() {
EntrySetView es = this.entrySetView;
return (es != null) ? es : (this.entrySetView = new AscendingEntrySetView());
}
@Override
@Nullable
TreeMap.Entry subLowest() {
return absLowest();
}
@Override
@Nullable
TreeMap.Entry subHighest() {
return absHighest();
}
@Override
@Nullable
TreeMap.Entry subCeiling(K key) {
return absCeiling(key);
}
@Override
@Nullable
TreeMap.Entry subHigher(K key) {
return absHigher(key);
}
@Override
@Nullable
TreeMap.Entry subFloor(K key) {
return absFloor(key);
}
@Override
@Nullable
TreeMap.Entry subLower(K key) {
return absLower(key);
}
}
/**
* @serial include
*/
static final class DescendingSubMap extends NavigableSubMap {
private static final long serialVersionUID = 912986545866120460L;
DescendingSubMap(TreeMap m, boolean fromStart, @Nullable K lo, boolean loInclusive, boolean toEnd,
@Nullable K hi, boolean hiInclusive) {
super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
}
private final Comparator reverseComparator = Collections.reverseOrder(this.m.comparator);
@Override
public Comparator comparator() {
return this.reverseComparator;
}
@Override
public NavigableMap subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
if (!inRange(fromKey, fromInclusive)) {
throw new IllegalArgumentException("fromKey out of range");
}
if (!inRange(toKey, toInclusive)) {
throw new IllegalArgumentException("toKey out of range");
}
return new DescendingSubMap<>(this.m, false, toKey, toInclusive, false, fromKey, fromInclusive);
}
@Override
public NavigableMap headMap(K toKey, boolean inclusive) {
if (!inRange(toKey, inclusive)) {
throw new IllegalArgumentException("toKey out of range");
}
return new DescendingSubMap<>(this.m, false, toKey, inclusive, this.toEnd, this.hi, this.hiInclusive);
}
@Override
public NavigableMap tailMap(K fromKey, boolean inclusive) {
if (!inRange(fromKey, inclusive)) {
throw new IllegalArgumentException("fromKey out of range");
}
return new DescendingSubMap<>(this.m, this.fromStart, this.lo, this.loInclusive, false, fromKey, inclusive);
}
@Override
public NavigableMap descendingMap() {
NavigableMap mv = this.descendingMapView;
return (mv != null) ? mv
: (this.descendingMapView = new AscendingSubMap<>(this.m, this.fromStart, this.lo, this.loInclusive,
this.toEnd, this.hi, this.hiInclusive));
}
@Override
Iterator keyIterator() {
return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
}
@Override
Iterator descendingKeyIterator() {
return new SubMapKeyIterator(absLowest(), absHighFence());
}
final class DescendingEntrySetView extends EntrySetView {
@Override
public Iterator> iterator() {
return new DescendingSubMapEntryIterator(absHighest(), absLowFence());
}
}
@Override
public Set> entrySet() {
EntrySetView es = this.entrySetView;
return (es != null) ? es : (this.entrySetView = new DescendingEntrySetView());
}
@Override
@Nullable
TreeMap.Entry subLowest() {
return absHighest();
}
@Override
@Nullable
TreeMap.Entry subHighest() {
return absLowest();
}
@Override
@Nullable
TreeMap.Entry subCeiling(K key) {
return absFloor(key);
}
@Override
@Nullable
TreeMap.Entry subHigher(K key) {
return absLower(key);
}
@Override
@Nullable
TreeMap.Entry subFloor(K key) {
return absCeiling(key);
}
@Override
@Nullable
TreeMap.Entry subLower(K key) {
return absHigher(key);
}
}
// Red-black mechanics
private static final boolean RED = false;
private static final boolean BLACK = true;
/**
* Node in the Tree. Doubles as a means to pass key-value pairs back to user (see Map.Entry).
*/
static final class Entry implements Map.Entry {
K key;
V value;
@Nullable
Entry left;
@Nullable
Entry right;
@Nullable
Entry parent;
boolean color = BLACK;
/**
* Make a new cell with given key, value, and parent, and with {@code null} child links, and BLACK color.
*/
Entry(K key, V value, @Nullable Entry parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
/**
* Returns the key.
*
* @return the key
*/
@Override
public K getKey() {
return this.key;
}
/**
* Returns the value associated with the key.
*
* @return the value associated with the key
*/
@Override
public V getValue() {
return this.value;
}
/**
* Replaces the value currently associated with the key with the given value.
*
* @return the value associated with the key before this method was called
*/
@Override
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry e = (Map.Entry) o;
return valEquals(this.key, e.getKey()) && valEquals(this.value, e.getValue());
}
@Override
public int hashCode() {
int keyHash = (this.key == null ? 0 : this.key.hashCode());
int valueHash = (this.value == null ? 0 : this.value.hashCode());
return keyHash ^ valueHash;
}
@Override
public String toString() {
return this.key + "=" + this.value;
}
}
/**
* Returns the first Entry in the TreeMap (according to the TreeMap's key-sort function). Returns null if the
* TreeMap is empty.
*/
@Nullable
final Entry getFirstEntry() {
Entry p = this.root;
if (p != null) {
while (p.left != null) {
p = p.left;
}
}
return p;
}
/**
* Returns the last Entry in the TreeMap (according to the TreeMap's key-sort function). Returns null if the TreeMap
* is empty.
*/
@Nullable
final Entry getLastEntry() {
Entry p = this.root;
if (p != null) {
while (p.right != null) {
p = p.right;
}
}
return p;
}
/**
* Returns the successor of the specified Entry, or null if no such.
*/
@Nullable
static TreeMap.Entry successor(@Nullable Entry t) {
if (t == null) {
return null;
} else if (t.right != null) {
Entry p = t.right;
while (p.left != null) {
p = p.left;
}
return p;
} else {
Entry p = t.parent;
Entry ch = t;
while (p != null && ch == p.right) {
ch = p;
p = p.parent;
}
return p;
}
}
/**
* Returns the predecessor of the specified Entry, or null if no such.
*/
@Nullable
static Entry predecessor(@Nullable Entry t) {
if (t == null) {
return null;
} else if (t.left != null) {
Entry