My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/util/TreeMap.java (1 of 18352 files). Show all

Unified · Split

@@ -0,0 +1,2442 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.util;
	27
	28	/**
	29	* A Red-Black tree based {@link NavigableMap} implementation.
	30	* The map is sorted according to the {@linkplain Comparable natural
	31	* ordering} of its keys, or by a {@link Comparator} provided at map
	32	* creation time, depending on which constructor is used.
	33	*
	34	* <p>This implementation provides guaranteed log(n) time cost for the
	35	* {@code containsKey}, {@code get}, {@code put} and {@code remove}
	36	* operations. Algorithms are adaptations of those in Cormen, Leiserson, and
	37	* Rivest's <em>Introduction to Algorithms</em>.
	38	*
	39	* <p>Note that the ordering maintained by a tree map, like any sorted map, and
	40	* whether or not an explicit comparator is provided, must be <em>consistent
	41	* with {@code equals}</em> if this sorted map is to correctly implement the
	42	* {@code Map} interface. (See {@code Comparable} or {@code Comparator} for a
	43	* precise definition of <em>consistent with equals</em>.) This is so because
	44	* the {@code Map} interface is defined in terms of the {@code equals}
	45	* operation, but a sorted map performs all key comparisons using its {@code
	46	* compareTo} (or {@code compare}) method, so two keys that are deemed equal by
	47	* this method are, from the standpoint of the sorted map, equal. The behavior
	48	* of a sorted map <em>is</em> well-defined even if its ordering is
	49	* inconsistent with {@code equals}; it just fails to obey the general contract
	50	* of the {@code Map} interface.
	51	*
	52	* <p><strong>Note that this implementation is not synchronized.</strong>
	53	* If multiple threads access a map concurrently, and at least one of the
	54	* threads modifies the map structurally, it <em>must</em> be synchronized
	55	* externally. (A structural modification is any operation that adds or
	56	* deletes one or more mappings; merely changing the value associated
	57	* with an existing key is not a structural modification.) This is
	58	* typically accomplished by synchronizing on some object that naturally
	59	* encapsulates the map.
	60	* If no such object exists, the map should be "wrapped" using the
	61	* {@link Collections#synchronizedSortedMap Collections.synchronizedSortedMap}
	62	* method. This is best done at creation time, to prevent accidental
	63	* unsynchronized access to the map: <pre>
	64	* SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));</pre>
	65	*
	66	* <p>The iterators returned by the {@code iterator} method of the collections
	67	* returned by all of this class's "collection view methods" are
	68	* <em>fail-fast</em>: if the map is structurally modified at any time after
	69	* the iterator is created, in any way except through the iterator's own
	70	* {@code remove} method, the iterator will throw a {@link
	71	* ConcurrentModificationException}. Thus, in the face of concurrent
	72	* modification, the iterator fails quickly and cleanly, rather than risking
	73	* arbitrary, non-deterministic behavior at an undetermined time in the future.
	74	*
	75	* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
	76	* as it is, generally speaking, impossible to make any hard guarantees in the
	77	* presence of unsynchronized concurrent modification. Fail-fast iterators
	78	* throw {@code ConcurrentModificationException} on a best-effort basis.
	79	* Therefore, it would be wrong to write a program that depended on this
	80	* exception for its correctness: <em>the fail-fast behavior of iterators
	81	* should be used only to detect bugs.</em>
	82	*
	83	* <p>All {@code Map.Entry} pairs returned by methods in this class
	84	* and its views represent snapshots of mappings at the time they were
	85	* produced. They do <strong>not</strong> support the {@code Entry.setValue}
	86	* method. (Note however that it is possible to change mappings in the
	87	* associated map using {@code put}.)
	88	*
	89	* <p>This class is a member of the
	90	* <a href="{@docRoot}/../technotes/guides/collections/index.html">
	91	* Java Collections Framework</a>.
	92	*
	93	* @param <K> the type of keys maintained by this map
	94	* @param <V> the type of mapped values
	95	*
	96	* @author Josh Bloch and Doug Lea
	97	* @see Map
	98	* @see HashMap
	99	* @see Hashtable
	100	* @see Comparable
	101	* @see Comparator
	102	* @see Collection
	103	* @since 1.2
	104	*/
	105
	106	public class TreeMap<K,V>
	107	extends AbstractMap<K,V>
	108	implements NavigableMap<K,V>, Cloneable, java.io.Serializable
	109	{
	110	/**
	111	* The comparator used to maintain order in this tree map, or
	112	* null if it uses the natural ordering of its keys.
	113	*
	114	* @serial
	115	*/
	116	private final Comparator<? super K> comparator;
	117
	118	private transient Entry<K,V> root = null;
	119
	120	/**
	121	* The number of entries in the tree
	122	*/
	123	private transient int size = 0;
	124
	125	/**
	126	* The number of structural modifications to the tree.
	127	*/
	128	private transient int modCount = 0;
	129
	130	/**
	131	* Constructs a new, empty tree map, using the natural ordering of its
	132	* keys. All keys inserted into the map must implement the {@link
	133	* Comparable} interface. Furthermore, all such keys must be
	134	* <em>mutually comparable</em>: {@code k1.compareTo(k2)} must not throw
	135	* a {@code ClassCastException} for any keys {@code k1} and
	136	* {@code k2} in the map. If the user attempts to put a key into the
	137	* map that violates this constraint (for example, the user attempts to
	138	* put a string key into a map whose keys are integers), the
	139	* {@code put(Object key, Object value)} call will throw a
	140	* {@code ClassCastException}.
	141	*/
	142	public TreeMap() {
	143	comparator = null;
	144	}
	145
	146	/**
	147	* Constructs a new, empty tree map, ordered according to the given
	148	* comparator. All keys inserted into the map must be <em>mutually
	149	* comparable</em> by the given comparator: {@code comparator.compare(k1,
	150	* k2)} must not throw a {@code ClassCastException} for any keys
	151	* {@code k1} and {@code k2} in the map. If the user attempts to put
	152	* a key into the map that violates this constraint, the {@code put(Object
	153	* key, Object value)} call will throw a
	154	* {@code ClassCastException}.
	155	*
	156	* @param comparator the comparator that will be used to order this map.
	157	* If {@code null}, the {@linkplain Comparable natural
	158	* ordering} of the keys will be used.
	159	*/
	160	public TreeMap(Comparator<? super K> comparator) {
	161	this.comparator = comparator;
	162	}
	163
	164	/**
	165	* Constructs a new tree map containing the same mappings as the given
	166	* map, ordered according to the <em>natural ordering</em> of its keys.
	167	* All keys inserted into the new map must implement the {@link
	168	* Comparable} interface. Furthermore, all such keys must be
	169	* <em>mutually comparable</em>: {@code k1.compareTo(k2)} must not throw
	170	* a {@code ClassCastException} for any keys {@code k1} and
	171	* {@code k2} in the map. This method runs in n*log(n) time.
	172	*
	173	* @param m the map whose mappings are to be placed in this map
	174	* @throws ClassCastException if the keys in m are not {@link Comparable},
	175	* or are not mutually comparable
	176	* @throws NullPointerException if the specified map is null
	177	*/
	178	public TreeMap(Map<? extends K, ? extends V> m) {
	179	comparator = null;
	180	putAll(m);
	181	}
	182
	183	/**
	184	* Constructs a new tree map containing the same mappings and
	185	* using the same ordering as the specified sorted map. This
	186	* method runs in linear time.
	187	*
	188	* @param m the sorted map whose mappings are to be placed in this map,
	189	* and whose comparator is to be used to sort this map
	190	* @throws NullPointerException if the specified map is null
	191	*/
	192	public TreeMap(SortedMap<K, ? extends V> m) {
	193	comparator = m.comparator();
	194	try {
	195	buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
	196	} catch (java.io.IOException cannotHappen) {
	197	} catch (ClassNotFoundException cannotHappen) {
	198	}
	199	}
	200
	201
	202	// Query Operations
	203
	204	/**
	205	* Returns the number of key-value mappings in this map.
	206	*
	207	* @return the number of key-value mappings in this map
	208	*/
	209	public int size() {
	210	return size;
	211	}
	212
	213	/**
	214	* Returns {@code true} if this map contains a mapping for the specified
	215	* key.
	216	*
	217	* @param key key whose presence in this map is to be tested
	218	* @return {@code true} if this map contains a mapping for the
	219	* specified key
	220	* @throws ClassCastException if the specified key cannot be compared
	221	* with the keys currently in the map
	222	* @throws NullPointerException if the specified key is null
	223	* and this map uses natural ordering, or its comparator
	224	* does not permit null keys
	225	*/
	226	public boolean containsKey(Object key) {
	227	return getEntry(key) != null;
	228	}
	229
	230	/**
	231	* Returns {@code true} if this map maps one or more keys to the
	232	* specified value. More formally, returns {@code true} if and only if
	233	* this map contains at least one mapping to a value {@code v} such
	234	* that {@code (value==null ? v==null : value.equals(v))}. This
	235	* operation will probably require time linear in the map size for
	236	* most implementations.
	237	*
	238	* @param value value whose presence in this map is to be tested
	239	* @return {@code true} if a mapping to {@code value} exists;
	240	* {@code false} otherwise
	241	* @since 1.2
	242	*/
	243	public boolean containsValue(Object value) {
	244	for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e))
	245	if (valEquals(value, e.value))
	246	return true;
	247	return false;
	248	}
	249
	250	/**
	251	* Returns the value to which the specified key is mapped,
	252	* or {@code null} if this map contains no mapping for the key.
	253	*
	254	* <p>More formally, if this map contains a mapping from a key
	255	* {@code k} to a value {@code v} such that {@code key} compares
	256	* equal to {@code k} according to the map's ordering, then this
	257	* method returns {@code v}; otherwise it returns {@code null}.
	258	* (There can be at most one such mapping.)
	259	*
	260	* <p>A return value of {@code null} does not <em>necessarily</em>
	261	* indicate that the map contains no mapping for the key; it's also
	262	* possible that the map explicitly maps the key to {@code null}.
	263	* The {@link #containsKey containsKey} operation may be used to
	264	* distinguish these two cases.
	265	*
	266	* @throws ClassCastException if the specified key cannot be compared
	267	* with the keys currently in the map
	268	* @throws NullPointerException if the specified key is null
	269	* and this map uses natural ordering, or its comparator
	270	* does not permit null keys
	271	*/
	272	public V get(Object key) {
	273	Entry<K,V> p = getEntry(key);
	274	return (p==null ? null : p.value);
	275	}
	276
	277	public Comparator<? super K> comparator() {
	278	return comparator;
	279	}
	280
	281	/**
	282	* @throws NoSuchElementException {@inheritDoc}
	283	*/
	284	public K firstKey() {
	285	return key(getFirstEntry());
	286	}
	287
	288	/**
	289	* @throws NoSuchElementException {@inheritDoc}
	290	*/
	291	public K lastKey() {
	292	return key(getLastEntry());
	293	}
	294
	295	/**
	296	* Copies all of the mappings from the specified map to this map.
	297	* These mappings replace any mappings that this map had for any
	298	* of the keys currently in the specified map.
	299	*
	300	* @param map mappings to be stored in this map
	301	* @throws ClassCastException if the class of a key or value in
	302	* the specified map prevents it from being stored in this map
	303	* @throws NullPointerException if the specified map is null or
	304	* the specified map contains a null key and this map does not
	305	* permit null keys
	306	*/
	307	public void putAll(Map<? extends K, ? extends V> map) {
	308	int mapSize = map.size();
	309	if (size==0 && mapSize!=0 && map instanceof SortedMap) {
	310	Comparator c = ((SortedMap)map).comparator();
	311	if (c == comparator \|\| (c != null && c.equals(comparator))) {
	312	++modCount;
	313	try {
	314	buildFromSorted(mapSize, map.entrySet().iterator(),
	315	null, null);
	316	} catch (java.io.IOException cannotHappen) {
	317	} catch (ClassNotFoundException cannotHappen) {
	318	}
	319	return;
	320	}
	321	}
	322	super.putAll(map);
	323	}
	324
	325	/**
	326	* Returns this map's entry for the given key, or {@code null} if the map
	327	* does not contain an entry for the key.
	328	*
	329	* @return this map's entry for the given key, or {@code null} if the map
	330	* does not contain an entry for the key
	331	* @throws ClassCastException if the specified key cannot be compared
	332	* with the keys currently in the map
	333	* @throws NullPointerException if the specified key is null
	334	* and this map uses natural ordering, or its comparator
	335	* does not permit null keys
	336	*/
	337	final Entry<K,V> getEntry(Object key) {
	338	// Offload comparator-based version for sake of performance
	339	if (comparator != null)
	340	return getEntryUsingComparator(key);
	341	if (key == null)
	342	throw new NullPointerException();
	343	Comparable<? super K> k = (Comparable<? super K>) key;
	344	Entry<K,V> p = root;
	345	while (p != null) {
	346	int cmp = k.compareTo(p.key);
	347	if (cmp < 0)
	348	p = p.left;
	349	else if (cmp > 0)
	350	p = p.right;
	351	else
	352	return p;
	353	}
	354	return null;
	355	}
	356
	357	/**
	358	* Version of getEntry using comparator. Split off from getEntry
	359	* for performance. (This is not worth doing for most methods,
	360	* that are less dependent on comparator performance, but is
	361	* worthwhile here.)
	362	*/
	363	final Entry<K,V> getEntryUsingComparator(Object key) {
	364	K k = (K) key;
	365	Comparator<? super K> cpr = comparator;
	366	if (cpr != null) {
	367	Entry<K,V> p = root;
	368	while (p != null) {
	369	int cmp = cpr.compare(k, p.key);
	370	if (cmp < 0)
	371	p = p.left;
	372	else if (cmp > 0)
	373	p = p.right;
	374	else
	375	return p;
	376	}
	377	}
	378	return null;
	379	}
	380
	381	/**
	382	* Gets the entry corresponding to the specified key; if no such entry
	383	* exists, returns the entry for the least key greater than the specified
	384	* key; if no such entry exists (i.e., the greatest key in the Tree is less
	385	* than the specified key), returns {@code null}.
	386	*/
	387	final Entry<K,V> getCeilingEntry(K key) {
	388	Entry<K,V> p = root;
	389	while (p != null) {
	390	int cmp = compare(key, p.key);
	391	if (cmp < 0) {
	392	if (p.left != null)
	393	p = p.left;
	394	else
	395	return p;
	396	} else if (cmp > 0) {
	397	if (p.right != null) {
	398	p = p.right;
	399	} else {
	400	Entry<K,V> parent = p.parent;
	401	Entry<K,V> ch = p;
	402	while (parent != null && ch == parent.right) {
	403	ch = parent;
	404	parent = parent.parent;
	405	}
	406	return parent;
	407	}
	408	} else
	409	return p;
	410	}
	411	return null;
	412	}
	413
	414	/**
	415	* Gets the entry corresponding to the specified key; if no such entry
	416	* exists, returns the entry for the greatest key less than the specified
	417	* key; if no such entry exists, returns {@code null}.
	418	*/
	419	final Entry<K,V> getFloorEntry(K key) {
	420	Entry<K,V> p = root;
	421	while (p != null) {
	422	int cmp = compare(key, p.key);
	423	if (cmp > 0) {
	424	if (p.right != null)
	425	p = p.right;
	426	else
	427	return p;
	428	} else if (cmp < 0) {
	429	if (p.left != null) {
	430	p = p.left;
	431	} else {
	432	Entry<K,V> parent = p.parent;
	433	Entry<K,V> ch = p;
	434	while (parent != null && ch == parent.left) {
	435	ch = parent;
	436	parent = parent.parent;
	437	}
	438	return parent;
	439	}
	440	} else
	441	return p;
	442
	443	}
	444	return null;
	445	}
	446
	447	/**
	448	* Gets the entry for the least key greater than the specified
	449	* key; if no such entry exists, returns the entry for the least
	450	* key greater than the specified key; if no such entry exists
	451	* returns {@code null}.
	452	*/
	453	final Entry<K,V> getHigherEntry(K key) {
	454	Entry<K,V> p = root;
	455	while (p != null) {
	456	int cmp = compare(key, p.key);
	457	if (cmp < 0) {
	458	if (p.left != null)
	459	p = p.left;
	460	else
	461	return p;
	462	} else {
	463	if (p.right != null) {
	464	p = p.right;
	465	} else {
	466	Entry<K,V> parent = p.parent;
	467	Entry<K,V> ch = p;
	468	while (parent != null && ch == parent.right) {
	469	ch = parent;
	470	parent = parent.parent;
	471	}
	472	return parent;
	473	}
	474	}
	475	}
	476	return null;
	477	}
	478
	479	/**
	480	* Returns the entry for the greatest key less than the specified key; if
	481	* no such entry exists (i.e., the least key in the Tree is greater than
	482	* the specified key), returns {@code null}.
	483	*/
	484	final Entry<K,V> getLowerEntry(K key) {
	485	Entry<K,V> p = root;
	486	while (p != null) {
	487	int cmp = compare(key, p.key);
	488	if (cmp > 0) {
	489	if (p.right != null)
	490	p = p.right;
	491	else
	492	return p;
	493	} else {
	494	if (p.left != null) {
	495	p = p.left;
	496	} else {
	497	Entry<K,V> parent = p.parent;
	498	Entry<K,V> ch = p;
	499	while (parent != null && ch == parent.left) {
	500	ch = parent;
	501	parent = parent.parent;
	502	}
	503	return parent;
	504	}
	505	}
	506	}
	507	return null;
	508	}
	509
	510	/**
	511	* Associates the specified value with the specified key in this map.
	512	* If the map previously contained a mapping for the key, the old
	513	* value is replaced.
	514	*
	515	* @param key key with which the specified value is to be associated
	516	* @param value value to be associated with the specified key
	517	*
	518	* @return the previous value associated with {@code key}, or
	519	* {@code null} if there was no mapping for {@code key}.
	520	* (A {@code null} return can also indicate that the map
	521	* previously associated {@code null} with {@code key}.)
	522	* @throws ClassCastException if the specified key cannot be compared
	523	* with the keys currently in the map
	524	* @throws NullPointerException if the specified key is null
	525	* and this map uses natural ordering, or its comparator
	526	* does not permit null keys
	527	*/
	528	public V put(K key, V value) {
	529	Entry<K,V> t = root;
	530	if (t == null) {
	531	compare(key, key); // type (and possibly null) check
	532
	533	root = new Entry<>(key, value, null);
	534	size = 1;
	535	modCount++;
	536	return null;
	537	}
	538	int cmp;
	539	Entry<K,V> parent;
	540	// split comparator and comparable paths
	541	Comparator<? super K> cpr = comparator;
	542	if (cpr != null) {
	543	do {
	544	parent = t;
	545	cmp = cpr.compare(key, t.key);
	546	if (cmp < 0)
	547	t = t.left;
	548	else if (cmp > 0)
	549	t = t.right;
	550	else
	551	return t.setValue(value);
	552	} while (t != null);
	553	}
	554	else {
	555	if (key == null)
	556	throw new NullPointerException();
	557	Comparable<? super K> k = (Comparable<? super K>) key;
	558	do {
	559	parent = t;
	560	cmp = k.compareTo(t.key);
	561	if (cmp < 0)
	562	t = t.left;
	563	else if (cmp > 0)
	564	t = t.right;
	565	else
	566	return t.setValue(value);
	567	} while (t != null);
	568	}
	569	Entry<K,V> e = new Entry<>(key, value, parent);
	570	if (cmp < 0)
	571	parent.left = e;
	572	else
	573	parent.right = e;
	574	fixAfterInsertion(e);
	575	size++;
	576	modCount++;
	577	return null;
	578	}
	579
	580	/**
	581	* Removes the mapping for this key from this TreeMap if present.
	582	*
	583	* @param key key for which mapping should be removed
	584	* @return the previous value associated with {@code key}, or
	585	* {@code null} if there was no mapping for {@code key}.
	586	* (A {@code null} return can also indicate that the map
	587	* previously associated {@code null} with {@code key}.)
	588	* @throws ClassCastException if the specified key cannot be compared
	589	* with the keys currently in the map
	590	* @throws NullPointerException if the specified key is null
	591	* and this map uses natural ordering, or its comparator
	592	* does not permit null keys
	593	*/
	594	public V remove(Object key) {
	595	Entry<K,V> p = getEntry(key);
	596	if (p == null)
	597	return null;
	598
	599	V oldValue = p.value;
	600	deleteEntry(p);
	601	return oldValue;
	602	}
	603
	604	/**
	605	* Removes all of the mappings from this map.
	606	* The map will be empty after this call returns.
	607	*/
	608	public void clear() {
	609	modCount++;
	610	size = 0;
	611	root = null;
	612	}
	613
	614	/**
	615	* Returns a shallow copy of this {@code TreeMap} instance. (The keys and
	616	* values themselves are not cloned.)
	617	*
	618	* @return a shallow copy of this map
	619	*/
	620	public Object clone() {
	621	TreeMap<K,V> clone = null;
	622	try {
	623	clone = (TreeMap<K,V>) super.clone();
	624	} catch (CloneNotSupportedException e) {
	625	throw new InternalError();
	626	}
	627
	628	// Put clone into "virgin" state (except for comparator)
	629	clone.root = null;
	630	clone.size = 0;
	631	clone.modCount = 0;
	632	clone.entrySet = null;
	633	clone.navigableKeySet = null;
	634	clone.descendingMap = null;
	635
	636	// Initialize clone with our mappings
	637	try {
	638	clone.buildFromSorted(size, entrySet().iterator(), null, null);
	639	} catch (java.io.IOException cannotHappen) {
	640	} catch (ClassNotFoundException cannotHappen) {
	641	}
	642
	643	return clone;
	644	}
	645
	646	// NavigableMap API methods
	647
	648	/**
	649	* @since 1.6
	650	*/
	651	public Map.Entry<K,V> firstEntry() {
	652	return exportEntry(getFirstEntry());
	653	}
	654
	655	/**
	656	* @since 1.6
	657	*/
	658	public Map.Entry<K,V> lastEntry() {
	659	return exportEntry(getLastEntry());
	660	}
	661
	662	/**
	663	* @since 1.6
	664	*/
	665	public Map.Entry<K,V> pollFirstEntry() {
	666	Entry<K,V> p = getFirstEntry();
	667	Map.Entry<K,V> result = exportEntry(p);
	668	if (p != null)
	669	deleteEntry(p);
	670	return result;
	671	}
	672
	673	/**
	674	* @since 1.6
	675	*/
	676	public Map.Entry<K,V> pollLastEntry() {
	677	Entry<K,V> p = getLastEntry();
	678	Map.Entry<K,V> result = exportEntry(p);
	679	if (p != null)
	680	deleteEntry(p);
	681	return result;
	682	}
	683
	684	/**
	685	* @throws ClassCastException {@inheritDoc}
	686	* @throws NullPointerException if the specified key is null
	687	* and this map uses natural ordering, or its comparator
	688	* does not permit null keys
	689	* @since 1.6
	690	*/
	691	public Map.Entry<K,V> lowerEntry(K key) {
	692	return exportEntry(getLowerEntry(key));
	693	}
	694
	695	/**
	696	* @throws ClassCastException {@inheritDoc}
	697	* @throws NullPointerException if the specified key is null
	698	* and this map uses natural ordering, or its comparator
	699	* does not permit null keys
	700	* @since 1.6
	701	*/
	702	public K lowerKey(K key) {
	703	return keyOrNull(getLowerEntry(key));
	704	}
	705
	706	/**
	707	* @throws ClassCastException {@inheritDoc}
	708	* @throws NullPointerException if the specified key is null
	709	* and this map uses natural ordering, or its comparator
	710	* does not permit null keys
	711	* @since 1.6
	712	*/
	713	public Map.Entry<K,V> floorEntry(K key) {
	714	return exportEntry(getFloorEntry(key));
	715	}
	716
	717	/**
	718	* @throws ClassCastException {@inheritDoc}
	719	* @throws NullPointerException if the specified key is null
	720	* and this map uses natural ordering, or its comparator
	721	* does not permit null keys
	722	* @since 1.6
	723	*/
	724	public K floorKey(K key) {
	725	return keyOrNull(getFloorEntry(key));
	726	}
	727
	728	/**
	729	* @throws ClassCastException {@inheritDoc}
	730	* @throws NullPointerException if the specified key is null
	731	* and this map uses natural ordering, or its comparator
	732	* does not permit null keys
	733	* @since 1.6
	734	*/
	735	public Map.Entry<K,V> ceilingEntry(K key) {
	736	return exportEntry(getCeilingEntry(key));
	737	}
	738
	739	/**
	740	* @throws ClassCastException {@inheritDoc}
	741	* @throws NullPointerException if the specified key is null
	742	* and this map uses natural ordering, or its comparator
	743	* does not permit null keys
	744	* @since 1.6
	745	*/
	746	public K ceilingKey(K key) {
	747	return keyOrNull(getCeilingEntry(key));
	748	}
	749
	750	/**
	751	* @throws ClassCastException {@inheritDoc}
	752	* @throws NullPointerException if the specified key is null
	753	* and this map uses natural ordering, or its comparator
	754	* does not permit null keys
	755	* @since 1.6
	756	*/
	757	public Map.Entry<K,V> higherEntry(K key) {
	758	return exportEntry(getHigherEntry(key));
	759	}
	760
	761	/**
	762	* @throws ClassCastException {@inheritDoc}
	763	* @throws NullPointerException if the specified key is null
	764	* and this map uses natural ordering, or its comparator
	765	* does not permit null keys
	766	* @since 1.6
	767	*/
	768	public K higherKey(K key) {
	769	return keyOrNull(getHigherEntry(key));
	770	}
	771
	772	// Views
	773
	774	/**
	775	* Fields initialized to contain an instance of the entry set view
	776	* the first time this view is requested. Views are stateless, so
	777	* there's no reason to create more than one.
	778	*/
	779	private transient EntrySet entrySet = null;
	780	private transient KeySet<K> navigableKeySet = null;
	781	private transient NavigableMap<K,V> descendingMap = null;
	782
	783	/**
	784	* Returns a {@link Set} view of the keys contained in this map.
	785	* The set's iterator returns the keys in ascending order.
	786	* The set is backed by the map, so changes to the map are
	787	* reflected in the set, and vice-versa. If the map is modified
	788	* while an iteration over the set is in progress (except through
	789	* the iterator's own {@code remove} operation), the results of
	790	* the iteration are undefined. The set supports element removal,
	791	* which removes the corresponding mapping from the map, via the
	792	* {@code Iterator.remove}, {@code Set.remove},
	793	* {@code removeAll}, {@code retainAll}, and {@code clear}
	794	* operations. It does not support the {@code add} or {@code addAll}
	795	* operations.
	796	*/
	797	public Set<K> keySet() {
	798	return navigableKeySet();
	799	}
	800
	801	/**
	802	* @since 1.6
	803	*/
	804	public NavigableSet<K> navigableKeySet() {
	805	KeySet<K> nks = navigableKeySet;
	806	return (nks != null) ? nks : (navigableKeySet = new KeySet(this));
	807	}
	808
	809	/**
	810	* @since 1.6
	811	*/
	812	public NavigableSet<K> descendingKeySet() {
	813	return descendingMap().navigableKeySet();
	814	}
	815
	816	/**
	817	* Returns a {@link Collection} view of the values contained in this map.
	818	* The collection's iterator returns the values in ascending order
	819	* of the corresponding keys.
	820	* The collection is backed by the map, so changes to the map are
	821	* reflected in the collection, and vice-versa. If the map is
	822	* modified while an iteration over the collection is in progress
	823	* (except through the iterator's own {@code remove} operation),
	824	* the results of the iteration are undefined. The collection
	825	* supports element removal, which removes the corresponding
	826	* mapping from the map, via the {@code Iterator.remove},
	827	* {@code Collection.remove}, {@code removeAll},
	828	* {@code retainAll} and {@code clear} operations. It does not
	829	* support the {@code add} or {@code addAll} operations.
	830	*/
	831	public Collection<V> values() {
	832	Collection<V> vs = values;
	833	return (vs != null) ? vs : (values = new Values());
	834	}
	835
	836	/**
	837	* Returns a {@link Set} view of the mappings contained in this map.
	838	* The set's iterator returns the entries in ascending key order.
	839	* The set is backed by the map, so changes to the map are
	840	* reflected in the set, and vice-versa. If the map is modified
	841	* while an iteration over the set is in progress (except through
	842	* the iterator's own {@code remove} operation, or through the
	843	* {@code setValue} operation on a map entry returned by the
	844	* iterator) the results of the iteration are undefined. The set
	845	* supports element removal, which removes the corresponding
	846	* mapping from the map, via the {@code Iterator.remove},
	847	* {@code Set.remove}, {@code removeAll}, {@code retainAll} and
	848	* {@code clear} operations. It does not support the
	849	* {@code add} or {@code addAll} operations.
	850	*/
	851	public Set<Map.Entry<K,V>> entrySet() {
	852	EntrySet es = entrySet;
	853	return (es != null) ? es : (entrySet = new EntrySet());
	854	}
	855
	856	/**
	857	* @since 1.6
	858	*/
	859	public NavigableMap<K, V> descendingMap() {
	860	NavigableMap<K, V> km = descendingMap;
	861	return (km != null) ? km :
	862	(descendingMap = new DescendingSubMap(this,
	863	true, null, true,
	864	true, null, true));
	865	}
	866
	867	/**
	868	* @throws ClassCastException {@inheritDoc}
	869	* @throws NullPointerException if {@code fromKey} or {@code toKey} is
	870	* null and this map uses natural ordering, or its comparator
	871	* does not permit null keys
	872	* @throws IllegalArgumentException {@inheritDoc}
	873	* @since 1.6
	874	*/
	875	public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
	876	K toKey, boolean toInclusive) {
	877	return new AscendingSubMap(this,
	878	false, fromKey, fromInclusive,
	879	false, toKey, toInclusive);
	880	}
	881
	882	/**
	883	* @throws ClassCastException {@inheritDoc}
	884	* @throws NullPointerException if {@code toKey} is null
	885	* and this map uses natural ordering, or its comparator
	886	* does not permit null keys
	887	* @throws IllegalArgumentException {@inheritDoc}
	888	* @since 1.6
	889	*/
	890	public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
	891	return new AscendingSubMap(this,
	892	true, null, true,
	893	false, toKey, inclusive);
	894	}
	895
	896	/**
	897	* @throws ClassCastException {@inheritDoc}
	898	* @throws NullPointerException if {@code fromKey} is null
	899	* and this map uses natural ordering, or its comparator
	900	* does not permit null keys
	901	* @throws IllegalArgumentException {@inheritDoc}
	902	* @since 1.6
	903	*/
	904	public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
	905	return new AscendingSubMap(this,
	906	false, fromKey, inclusive,
	907	true, null, true);
	908	}
	909
	910	/**
	911	* @throws ClassCastException {@inheritDoc}
	912	* @throws NullPointerException if {@code fromKey} or {@code toKey} is
	913	* null and this map uses natural ordering, or its comparator
	914	* does not permit null keys
	915	* @throws IllegalArgumentException {@inheritDoc}
	916	*/
	917	public SortedMap<K,V> subMap(K fromKey, K toKey) {
	918	return subMap(fromKey, true, toKey, false);
	919	}
	920
	921	/**
	922	* @throws ClassCastException {@inheritDoc}
	923	* @throws NullPointerException if {@code toKey} is null
	924	* and this map uses natural ordering, or its comparator
	925	* does not permit null keys
	926	* @throws IllegalArgumentException {@inheritDoc}
	927	*/
	928	public SortedMap<K,V> headMap(K toKey) {
	929	return headMap(toKey, false);
	930	}
	931
	932	/**
	933	* @throws ClassCastException {@inheritDoc}
	934	* @throws NullPointerException if {@code fromKey} is null
	935	* and this map uses natural ordering, or its comparator
	936	* does not permit null keys
	937	* @throws IllegalArgumentException {@inheritDoc}
	938	*/
	939	public SortedMap<K,V> tailMap(K fromKey) {
	940	return tailMap(fromKey, true);
	941	}
	942
	943	// View class support
	944
	945	class Values extends AbstractCollection<V> {
	946	public Iterator<V> iterator() {
	947	return new ValueIterator(getFirstEntry());
	948	}
	949
	950	public int size() {
	951	return TreeMap.this.size();
	952	}
	953
	954	public boolean contains(Object o) {
	955	return TreeMap.this.containsValue(o);
	956	}
	957
	958	public boolean remove(Object o) {
	959	for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e)) {
	960	if (valEquals(e.getValue(), o)) {
	961	deleteEntry(e);
	962	return true;
	963	}
	964	}
	965	return false;
	966	}
	967
	968	public void clear() {
	969	TreeMap.this.clear();
	970	}
	971	}
	972
	973	class EntrySet extends AbstractSet<Map.Entry<K,V>> {
	974	public Iterator<Map.Entry<K,V>> iterator() {
	975	return new EntryIterator(getFirstEntry());
	976	}
	977
	978	public boolean contains(Object o) {
	979	if (!(o instanceof Map.Entry))
	980	return false;
	981	Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
	982	V value = entry.getValue();
	983	Entry<K,V> p = getEntry(entry.getKey());
	984	return p != null && valEquals(p.getValue(), value);
	985	}
	986
	987	public boolean remove(Object o) {
	988	if (!(o instanceof Map.Entry))
	989	return false;
	990	Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
	991	V value = entry.getValue();
	992	Entry<K,V> p = getEntry(entry.getKey());
	993	if (p != null && valEquals(p.getValue(), value)) {
	994	deleteEntry(p);
	995	return true;
	996	}
	997	return false;
	998	}
	999
	1000	public int size() {
	1001	return TreeMap.this.size();
	1002	}
	1003
	1004	public void clear() {
	1005	TreeMap.this.clear();
	1006	}
	1007	}
	1008
	1009	/*
	1010	* Unlike Values and EntrySet, the KeySet class is static,
	1011	* delegating to a NavigableMap to allow use by SubMaps, which
	1012	* outweighs the ugliness of needing type-tests for the following
	1013	* Iterator methods that are defined appropriately in main versus
	1014	* submap classes.
	1015	*/
	1016
	1017	Iterator<K> keyIterator() {
	1018	return new KeyIterator(getFirstEntry());
	1019	}
	1020
	1021	Iterator<K> descendingKeyIterator() {
	1022	return new DescendingKeyIterator(getLastEntry());
	1023	}
	1024
	1025	static final class KeySet<E> extends AbstractSet<E> implements NavigableSet<E> {
	1026	private final NavigableMap<E, Object> m;
	1027	KeySet(NavigableMap<E,Object> map) { m = map; }
	1028
	1029	public Iterator<E> iterator() {
	1030	if (m instanceof TreeMap)
	1031	return ((TreeMap<E,Object>)m).keyIterator();
	1032	else
	1033	return (Iterator<E>)(((TreeMap.NavigableSubMap)m).keyIterator());
	1034	}
	1035
	1036	public Iterator<E> descendingIterator() {
	1037	if (m instanceof TreeMap)
	1038	return ((TreeMap<E,Object>)m).descendingKeyIterator();
	1039	else
	1040	return (Iterator<E>)(((TreeMap.NavigableSubMap)m).descendingKeyIterator());
	1041	}
	1042
	1043	public int size() { return m.size(); }
	1044	public boolean isEmpty() { return m.isEmpty(); }
	1045	public boolean contains(Object o) { return m.containsKey(o); }
	1046	public void clear() { m.clear(); }
	1047	public E lower(E e) { return m.lowerKey(e); }
	1048	public E floor(E e) { return m.floorKey(e); }
	1049	public E ceiling(E e) { return m.ceilingKey(e); }
	1050	public E higher(E e) { return m.higherKey(e); }
	1051	public E first() { return m.firstKey(); }
	1052	public E last() { return m.lastKey(); }
	1053	public Comparator<? super E> comparator() { return m.comparator(); }
	1054	public E pollFirst() {
	1055	Map.Entry<E,Object> e = m.pollFirstEntry();
	1056	return (e == null) ? null : e.getKey();
	1057	}
	1058	public E pollLast() {
	1059	Map.Entry<E,Object> e = m.pollLastEntry();
	1060	return (e == null) ? null : e.getKey();
	1061	}
	1062	public boolean remove(Object o) {
	1063	int oldSize = size();
	1064	m.remove(o);
	1065	return size() != oldSize;
	1066	}
	1067	public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
	1068	E toElement, boolean toInclusive) {
	1069	return new KeySet<>(m.subMap(fromElement, fromInclusive,
	1070	toElement, toInclusive));
	1071	}
	1072	public NavigableSet<E> headSet(E toElement, boolean inclusive) {
	1073	return new KeySet<>(m.headMap(toElement, inclusive));
	1074	}
	1075	public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
	1076	return new KeySet<>(m.tailMap(fromElement, inclusive));
	1077	}
	1078	public SortedSet<E> subSet(E fromElement, E toElement) {
	1079	return subSet(fromElement, true, toElement, false);
	1080	}
	1081	public SortedSet<E> headSet(E toElement) {
	1082	return headSet(toElement, false);
	1083	}
	1084	public SortedSet<E> tailSet(E fromElement) {
	1085	return tailSet(fromElement, true);
	1086	}
	1087	public NavigableSet<E> descendingSet() {
	1088	return new KeySet(m.descendingMap());
	1089	}
	1090	}
	1091
	1092	/**
	1093	* Base class for TreeMap Iterators
	1094	*/
	1095	abstract class PrivateEntryIterator<T> implements Iterator<T> {
	1096	Entry<K,V> next;
	1097	Entry<K,V> lastReturned;
	1098	int expectedModCount;
	1099
	1100	PrivateEntryIterator(Entry<K,V> first) {
	1101	expectedModCount = modCount;
	1102	lastReturned = null;
	1103	next = first;
	1104	}
	1105
	1106	public final boolean hasNext() {
	1107	return next != null;
	1108	}
	1109
	1110	final Entry<K,V> nextEntry() {
	1111	Entry<K,V> e = next;
	1112	if (e == null)
	1113	throw new NoSuchElementException();
	1114	if (modCount != expectedModCount)
	1115	throw new ConcurrentModificationException();
	1116	next = successor(e);
	1117	lastReturned = e;
	1118	return e;
	1119	}
	1120
	1121	final Entry<K,V> prevEntry() {
	1122	Entry<K,V> e = next;
	1123	if (e == null)
	1124	throw new NoSuchElementException();
	1125	if (modCount != expectedModCount)
	1126	throw new ConcurrentModificationException();
	1127	next = predecessor(e);
	1128	lastReturned = e;
	1129	return e;
	1130	}
	1131
	1132	public void remove() {
	1133	if (lastReturned == null)
	1134	throw new IllegalStateException();
	1135	if (modCount != expectedModCount)
	1136	throw new ConcurrentModificationException();
	1137	// deleted entries are replaced by their successors
	1138	if (lastReturned.left != null && lastReturned.right != null)
	1139	next = lastReturned;
	1140	deleteEntry(lastReturned);
	1141	expectedModCount = modCount;
	1142	lastReturned = null;
	1143	}
	1144	}
	1145
	1146	final class EntryIterator extends PrivateEntryIterator<Map.Entry<K,V>> {
	1147	EntryIterator(Entry<K,V> first) {
	1148	super(first);
	1149	}
	1150	public Map.Entry<K,V> next() {
	1151	return nextEntry();
	1152	}
	1153	}
	1154
	1155	final class ValueIterator extends PrivateEntryIterator<V> {
	1156	ValueIterator(Entry<K,V> first) {
	1157	super(first);
	1158	}
	1159	public V next() {
	1160	return nextEntry().value;
	1161	}
	1162	}
	1163
	1164	final class KeyIterator extends PrivateEntryIterator<K> {
	1165	KeyIterator(Entry<K,V> first) {
	1166	super(first);
	1167	}
	1168	public K next() {
	1169	return nextEntry().key;
	1170	}
	1171	}
	1172
	1173	final class DescendingKeyIterator extends PrivateEntryIterator<K> {
	1174	DescendingKeyIterator(Entry<K,V> first) {
	1175	super(first);
	1176	}
	1177	public K next() {
	1178	return prevEntry().key;
	1179	}
	1180	}
	1181
	1182	// Little utilities
	1183
	1184	/**
	1185	* Compares two keys using the correct comparison method for this TreeMap.
	1186	*/
	1187	final int compare(Object k1, Object k2) {
	1188	return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
	1189	: comparator.compare((K)k1, (K)k2);
	1190	}
	1191
	1192	/**
	1193	* Test two values for equality. Differs from o1.equals(o2) only in
	1194	* that it copes with {@code null} o1 properly.
	1195	*/
	1196	static final boolean valEquals(Object o1, Object o2) {
	1197	return (o1==null ? o2==null : o1.equals(o2));
	1198	}
	1199
	1200	/**
	1201	* Return SimpleImmutableEntry for entry, or null if null
	1202	*/
	1203	static <K,V> Map.Entry<K,V> exportEntry(TreeMap.Entry<K,V> e) {
	1204	return (e == null) ? null :
	1205	new AbstractMap.SimpleImmutableEntry<>(e);
	1206	}
	1207
	1208	/**
	1209	* Return key for entry, or null if null
	1210	*/
	1211	static <K,V> K keyOrNull(TreeMap.Entry<K,V> e) {
	1212	return (e == null) ? null : e.key;
	1213	}
	1214
	1215	/**
	1216	* Returns the key corresponding to the specified Entry.
	1217	* @throws NoSuchElementException if the Entry is null
	1218	*/
	1219	static <K> K key(Entry<K,?> e) {
	1220	if (e==null)
	1221	throw new NoSuchElementException();
	1222	return e.key;
	1223	}
	1224
	1225
	1226	// SubMaps
	1227
	1228	/**
	1229	* Dummy value serving as unmatchable fence key for unbounded
	1230	* SubMapIterators
	1231	*/
	1232	private static final Object UNBOUNDED = new Object();
	1233
	1234	/**
	1235	* @serial include
	1236	*/
	1237	abstract static class NavigableSubMap<K,V> extends AbstractMap<K,V>
	1238	implements NavigableMap<K,V>, java.io.Serializable {
	1239	/**
	1240	* The backing map.
	1241	*/
	1242	final TreeMap<K,V> m;
	1243
	1244	/**
	1245	* Endpoints are represented as triples (fromStart, lo,
	1246	* loInclusive) and (toEnd, hi, hiInclusive). If fromStart is
	1247	* true, then the low (absolute) bound is the start of the
	1248	* backing map, and the other values are ignored. Otherwise,
	1249	* if loInclusive is true, lo is the inclusive bound, else lo
	1250	* is the exclusive bound. Similarly for the upper bound.
	1251	*/
	1252	final K lo, hi;
	1253	final boolean fromStart, toEnd;
	1254	final boolean loInclusive, hiInclusive;
	1255
	1256	NavigableSubMap(TreeMap<K,V> m,
	1257	boolean fromStart, K lo, boolean loInclusive,
	1258	boolean toEnd, K hi, boolean hiInclusive) {
	1259	if (!fromStart && !toEnd) {
	1260	if (m.compare(lo, hi) > 0)
	1261	throw new IllegalArgumentException("fromKey > toKey");
	1262	} else {
	1263	if (!fromStart) // type check
	1264	m.compare(lo, lo);
	1265	if (!toEnd)
	1266	m.compare(hi, hi);
	1267	}
	1268
	1269	this.m = m;
	1270	this.fromStart = fromStart;
	1271	this.lo = lo;
	1272	this.loInclusive = loInclusive;
	1273	this.toEnd = toEnd;
	1274	this.hi = hi;
	1275	this.hiInclusive = hiInclusive;
	1276	}
	1277
	1278	// internal utilities
	1279
	1280	final boolean tooLow(Object key) {
	1281	if (!fromStart) {
	1282	int c = m.compare(key, lo);
	1283	if (c < 0 \|\| (c == 0 && !loInclusive))
	1284	return true;
	1285	}
	1286	return false;
	1287	}
	1288
	1289	final boolean tooHigh(Object key) {
	1290	if (!toEnd) {
	1291	int c = m.compare(key, hi);
	1292	if (c > 0 \|\| (c == 0 && !hiInclusive))
	1293	return true;
	1294	}
	1295	return false;
	1296	}
	1297
	1298	final boolean inRange(Object key) {
	1299	return !tooLow(key) && !tooHigh(key);
	1300	}
	1301
	1302	final boolean inClosedRange(Object key) {
	1303	return (fromStart \|\| m.compare(key, lo) >= 0)
	1304	&& (toEnd \|\| m.compare(hi, key) >= 0);
	1305	}
	1306
	1307	final boolean inRange(Object key, boolean inclusive) {
	1308	return inclusive ? inRange(key) : inClosedRange(key);
	1309	}
	1310
	1311	/*
	1312	* Absolute versions of relation operations.
	1313	* Subclasses map to these using like-named "sub"
	1314	* versions that invert senses for descending maps
	1315	*/
	1316
	1317	final TreeMap.Entry<K,V> absLowest() {
	1318	TreeMap.Entry<K,V> e =
	1319	(fromStart ? m.getFirstEntry() :
	1320	(loInclusive ? m.getCeilingEntry(lo) :
	1321	m.getHigherEntry(lo)));
	1322	return (e == null \|\| tooHigh(e.key)) ? null : e;
	1323	}
	1324
	1325	final TreeMap.Entry<K,V> absHighest() {
	1326	TreeMap.Entry<K,V> e =
	1327	(toEnd ? m.getLastEntry() :
	1328	(hiInclusive ? m.getFloorEntry(hi) :
	1329	m.getLowerEntry(hi)));
	1330	return (e == null \|\| tooLow(e.key)) ? null : e;
	1331	}
	1332
	1333	final TreeMap.Entry<K,V> absCeiling(K key) {
	1334	if (tooLow(key))
	1335	return absLowest();
	1336	TreeMap.Entry<K,V> e = m.getCeilingEntry(key);
	1337	return (e == null \|\| tooHigh(e.key)) ? null : e;
	1338	}
	1339
	1340	final TreeMap.Entry<K,V> absHigher(K key) {
	1341	if (tooLow(key))
	1342	return absLowest();
	1343	TreeMap.Entry<K,V> e = m.getHigherEntry(key);
	1344	return (e == null \|\| tooHigh(e.key)) ? null : e;
	1345	}
	1346
	1347	final TreeMap.Entry<K,V> absFloor(K key) {
	1348	if (tooHigh(key))
	1349	return absHighest();
	1350	TreeMap.Entry<K,V> e = m.getFloorEntry(key);
	1351	return (e == null \|\| tooLow(e.key)) ? null : e;
	1352	}
	1353
	1354	final TreeMap.Entry<K,V> absLower(K key) {
	1355	if (tooHigh(key))
	1356	return absHighest();
	1357	TreeMap.Entry<K,V> e = m.getLowerEntry(key);
	1358	return (e == null \|\| tooLow(e.key)) ? null : e;
	1359	}
	1360
	1361	/** Returns the absolute high fence for ascending traversal */
	1362	final TreeMap.Entry<K,V> absHighFence() {
	1363	return (toEnd ? null : (hiInclusive ?
	1364	m.getHigherEntry(hi) :
	1365	m.getCeilingEntry(hi)));
	1366	}
	1367
	1368	/** Return the absolute low fence for descending traversal */
	1369	final TreeMap.Entry<K,V> absLowFence() {
	1370	return (fromStart ? null : (loInclusive ?
	1371	m.getLowerEntry(lo) :
	1372	m.getFloorEntry(lo)));
	1373	}
	1374
	1375	// Abstract methods defined in ascending vs descending classes
	1376	// These relay to the appropriate absolute versions
	1377
	1378	abstract TreeMap.Entry<K,V> subLowest();
	1379	abstract TreeMap.Entry<K,V> subHighest();
	1380	abstract TreeMap.Entry<K,V> subCeiling(K key);
	1381	abstract TreeMap.Entry<K,V> subHigher(K key);
	1382	abstract TreeMap.Entry<K,V> subFloor(K key);
	1383	abstract TreeMap.Entry<K,V> subLower(K key);
	1384
	1385	/** Returns ascending iterator from the perspective of this submap */
	1386	abstract Iterator<K> keyIterator();
	1387
	1388	/** Returns descending iterator from the perspective of this submap */
	1389	abstract Iterator<K> descendingKeyIterator();
	1390
	1391	// public methods
	1392
	1393	public boolean isEmpty() {
	1394	return (fromStart && toEnd) ? m.isEmpty() : entrySet().isEmpty();
	1395	}
	1396
	1397	public int size() {
	1398	return (fromStart && toEnd) ? m.size() : entrySet().size();
	1399	}
	1400
	1401	public final boolean containsKey(Object key) {
	1402	return inRange(key) && m.containsKey(key);
	1403	}
	1404
	1405	public final V put(K key, V value) {
	1406	if (!inRange(key))
	1407	throw new IllegalArgumentException("key out of range");
	1408	return m.put(key, value);
	1409	}
	1410
	1411	public final V get(Object key) {
	1412	return !inRange(key) ? null : m.get(key);
	1413	}
	1414
	1415	public final V remove(Object key) {
	1416	return !inRange(key) ? null : m.remove(key);
	1417	}
	1418
	1419	public final Map.Entry<K,V> ceilingEntry(K key) {
	1420	return exportEntry(subCeiling(key));
	1421	}
	1422
	1423	public final K ceilingKey(K key) {
	1424	return keyOrNull(subCeiling(key));
	1425	}
	1426
	1427	public final Map.Entry<K,V> higherEntry(K key) {
	1428	return exportEntry(subHigher(key));
	1429	}
	1430
	1431	public final K higherKey(K key) {
	1432	return keyOrNull(subHigher(key));
	1433	}
	1434
	1435	public final Map.Entry<K,V> floorEntry(K key) {
	1436	return exportEntry(subFloor(key));
	1437	}
	1438
	1439	public final K floorKey(K key) {
	1440	return keyOrNull(subFloor(key));
	1441	}
	1442
	1443	public final Map.Entry<K,V> lowerEntry(K key) {
	1444	return exportEntry(subLower(key));
	1445	}
	1446
	1447	public final K lowerKey(K key) {
	1448	return keyOrNull(subLower(key));
	1449	}
	1450
	1451	public final K firstKey() {
	1452	return key(subLowest());
	1453	}
	1454
	1455	public final K lastKey() {
	1456	return key(subHighest());
	1457	}
	1458
	1459	public final Map.Entry<K,V> firstEntry() {
	1460	return exportEntry(subLowest());
	1461	}
	1462
	1463	public final Map.Entry<K,V> lastEntry() {
	1464	return exportEntry(subHighest());
	1465	}
	1466
	1467	public final Map.Entry<K,V> pollFirstEntry() {
	1468	TreeMap.Entry<K,V> e = subLowest();
	1469	Map.Entry<K,V> result = exportEntry(e);
	1470	if (e != null)
	1471	m.deleteEntry(e);
	1472	return result;
	1473	}
	1474
	1475	public final Map.Entry<K,V> pollLastEntry() {
	1476	TreeMap.Entry<K,V> e = subHighest();
	1477	Map.Entry<K,V> result = exportEntry(e);
	1478	if (e != null)
	1479	m.deleteEntry(e);
	1480	return result;
	1481	}
	1482
	1483	// Views
	1484	transient NavigableMap<K,V> descendingMapView = null;
	1485	transient EntrySetView entrySetView = null;
	1486	transient KeySet<K> navigableKeySetView = null;
	1487
	1488	public final NavigableSet<K> navigableKeySet() {
	1489	KeySet<K> nksv = navigableKeySetView;
	1490	return (nksv != null) ? nksv :
	1491	(navigableKeySetView = new TreeMap.KeySet(this));
	1492	}
	1493
	1494	public final Set<K> keySet() {
	1495	return navigableKeySet();
	1496	}
	1497
	1498	public NavigableSet<K> descendingKeySet() {
	1499	return descendingMap().navigableKeySet();
	1500	}
	1501
	1502	public final SortedMap<K,V> subMap(K fromKey, K toKey) {
	1503	return subMap(fromKey, true, toKey, false);
	1504	}
	1505
	1506	public final SortedMap<K,V> headMap(K toKey) {
	1507	return headMap(toKey, false);
	1508	}
	1509
	1510	public final SortedMap<K,V> tailMap(K fromKey) {
	1511	return tailMap(fromKey, true);
	1512	}
	1513
	1514	// View classes
	1515
	1516	abstract class EntrySetView extends AbstractSet<Map.Entry<K,V>> {
	1517	private transient int size = -1, sizeModCount;
	1518
	1519	public int size() {
	1520	if (fromStart && toEnd)
	1521	return m.size();
	1522	if (size == -1 \|\| sizeModCount != m.modCount) {
	1523	sizeModCount = m.modCount;
	1524	size = 0;
	1525	Iterator i = iterator();
	1526	while (i.hasNext()) {
	1527	size++;
	1528	i.next();
	1529	}
	1530	}
	1531	return size;
	1532	}
	1533
	1534	public boolean isEmpty() {
	1535	TreeMap.Entry<K,V> n = absLowest();
	1536	return n == null \|\| tooHigh(n.key);
	1537	}
	1538
	1539	public boolean contains(Object o) {
	1540	if (!(o instanceof Map.Entry))
	1541	return false;
	1542	Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
	1543	K key = entry.getKey();
	1544	if (!inRange(key))
	1545	return false;
	1546	TreeMap.Entry node = m.getEntry(key);
	1547	return node != null &&
	1548	valEquals(node.getValue(), entry.getValue());
	1549	}
	1550
	1551	public boolean remove(Object o) {
	1552	if (!(o instanceof Map.Entry))
	1553	return false;
	1554	Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
	1555	K key = entry.getKey();
	1556	if (!inRange(key))
	1557	return false;
	1558	TreeMap.Entry<K,V> node = m.getEntry(key);
	1559	if (node!=null && valEquals(node.getValue(),
	1560	entry.getValue())) {
	1561	m.deleteEntry(node);
	1562	return true;
	1563	}
	1564	return false;
	1565	}
	1566	}
	1567
	1568	/**
	1569	* Iterators for SubMaps
	1570	*/
	1571	abstract class SubMapIterator<T> implements Iterator<T> {
	1572	TreeMap.Entry<K,V> lastReturned;
	1573	TreeMap.Entry<K,V> next;
	1574	final Object fenceKey;
	1575	int expectedModCount;
	1576
	1577	SubMapIterator(TreeMap.Entry<K,V> first,
	1578	TreeMap.Entry<K,V> fence) {
	1579	expectedModCount = m.modCount;
	1580	lastReturned = null;
	1581	next = first;
	1582	fenceKey = fence == null ? UNBOUNDED : fence.key;
	1583	}
	1584
	1585	public final boolean hasNext() {
	1586	return next != null && next.key != fenceKey;
	1587	}
	1588
	1589	final TreeMap.Entry<K,V> nextEntry() {
	1590	TreeMap.Entry<K,V> e = next;
	1591	if (e == null \|\| e.key == fenceKey)
	1592	throw new NoSuchElementException();
	1593	if (m.modCount != expectedModCount)
	1594	throw new ConcurrentModificationException();
	1595	next = successor(e);
	1596	lastReturned = e;
	1597	return e;
	1598	}
	1599
	1600	final TreeMap.Entry<K,V> prevEntry() {
	1601	TreeMap.Entry<K,V> e = next;
	1602	if (e == null \|\| e.key == fenceKey)
	1603	throw new NoSuchElementException();
	1604	if (m.modCount != expectedModCount)
	1605	throw new ConcurrentModificationException();
	1606	next = predecessor(e);
	1607	lastReturned = e;
	1608	return e;
	1609	}
	1610
	1611	final void removeAscending() {
	1612	if (lastReturned == null)
	1613	throw new IllegalStateException();
	1614	if (m.modCount != expectedModCount)
	1615	throw new ConcurrentModificationException();
	1616	// deleted entries are replaced by their successors
	1617	if (lastReturned.left != null && lastReturned.right != null)
	1618	next = lastReturned;
	1619	m.deleteEntry(lastReturned);
	1620	lastReturned = null;
	1621	expectedModCount = m.modCount;
	1622	}
	1623
	1624	final void removeDescending() {
	1625	if (lastReturned == null)
	1626	throw new IllegalStateException();
	1627	if (m.modCount != expectedModCount)
	1628	throw new ConcurrentModificationException();
	1629	m.deleteEntry(lastReturned);
	1630	lastReturned = null;
	1631	expectedModCount = m.modCount;
	1632	}
	1633
	1634	}
	1635
	1636	final class SubMapEntryIterator extends SubMapIterator<Map.Entry<K,V>> {
	1637	SubMapEntryIterator(TreeMap.Entry<K,V> first,
	1638	TreeMap.Entry<K,V> fence) {
	1639	super(first, fence);
	1640	}
	1641	public Map.Entry<K,V> next() {
	1642	return nextEntry();
	1643	}
	1644	public void remove() {
	1645	removeAscending();
	1646	}
	1647	}
	1648
	1649	final class SubMapKeyIterator extends SubMapIterator<K> {
	1650	SubMapKeyIterator(TreeMap.Entry<K,V> first,
	1651	TreeMap.Entry<K,V> fence) {
	1652	super(first, fence);
	1653	}
	1654	public K next() {
	1655	return nextEntry().key;
	1656	}
	1657	public void remove() {
	1658	removeAscending();
	1659	}
	1660	}
	1661
	1662	final class DescendingSubMapEntryIterator extends SubMapIterator<Map.Entry<K,V>> {
	1663	DescendingSubMapEntryIterator(TreeMap.Entry<K,V> last,
	1664	TreeMap.Entry<K,V> fence) {
	1665	super(last, fence);
	1666	}
	1667
	1668	public Map.Entry<K,V> next() {
	1669	return prevEntry();
	1670	}
	1671	public void remove() {
	1672	removeDescending();
	1673	}
	1674	}
	1675
	1676	final class DescendingSubMapKeyIterator extends SubMapIterator<K> {
	1677	DescendingSubMapKeyIterator(TreeMap.Entry<K,V> last,
	1678	TreeMap.Entry<K,V> fence) {
	1679	super(last, fence);
	1680	}
	1681	public K next() {
	1682	return prevEntry().key;
	1683	}
	1684	public void remove() {
	1685	removeDescending();
	1686	}
	1687	}
	1688	}
	1689
	1690	/**
	1691	* @serial include
	1692	*/
	1693	static final class AscendingSubMap<K,V> extends NavigableSubMap<K,V> {
	1694	private static final long serialVersionUID = 912986545866124060L;
	1695
	1696	AscendingSubMap(TreeMap<K,V> m,
	1697	boolean fromStart, K lo, boolean loInclusive,
	1698	boolean toEnd, K hi, boolean hiInclusive) {
	1699	super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
	1700	}
	1701
	1702	public Comparator<? super K> comparator() {
	1703	return m.comparator();
	1704	}
	1705
	1706	public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
	1707	K toKey, boolean toInclusive) {
	1708	if (!inRange(fromKey, fromInclusive))
	1709	throw new IllegalArgumentException("fromKey out of range");
	1710	if (!inRange(toKey, toInclusive))
	1711	throw new IllegalArgumentException("toKey out of range");
	1712	return new AscendingSubMap(m,
	1713	false, fromKey, fromInclusive,
	1714	false, toKey, toInclusive);
	1715	}
	1716
	1717	public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
	1718	if (!inRange(toKey, inclusive))
	1719	throw new IllegalArgumentException("toKey out of range");
	1720	return new AscendingSubMap(m,
	1721	fromStart, lo, loInclusive,
	1722	false, toKey, inclusive);
	1723	}
	1724
	1725	public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
	1726	if (!inRange(fromKey, inclusive))
	1727	throw new IllegalArgumentException("fromKey out of range");
	1728	return new AscendingSubMap(m,
	1729	false, fromKey, inclusive,
	1730	toEnd, hi, hiInclusive);
	1731	}
	1732
	1733	public NavigableMap<K,V> descendingMap() {
	1734	NavigableMap<K,V> mv = descendingMapView;
	1735	return (mv != null) ? mv :
	1736	(descendingMapView =
	1737	new DescendingSubMap(m,
	1738	fromStart, lo, loInclusive,
	1739	toEnd, hi, hiInclusive));
	1740	}
	1741
	1742	Iterator<K> keyIterator() {
	1743	return new SubMapKeyIterator(absLowest(), absHighFence());
	1744	}
	1745
	1746	Iterator<K> descendingKeyIterator() {
	1747	return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
	1748	}
	1749
	1750	final class AscendingEntrySetView extends EntrySetView {
	1751	public Iterator<Map.Entry<K,V>> iterator() {
	1752	return new SubMapEntryIterator(absLowest(), absHighFence());
	1753	}
	1754	}
	1755
	1756	public Set<Map.Entry<K,V>> entrySet() {
	1757	EntrySetView es = entrySetView;
	1758	return (es != null) ? es : new AscendingEntrySetView();
	1759	}
	1760
	1761	TreeMap.Entry<K,V> subLowest() { return absLowest(); }
	1762	TreeMap.Entry<K,V> subHighest() { return absHighest(); }
	1763	TreeMap.Entry<K,V> subCeiling(K key) { return absCeiling(key); }
	1764	TreeMap.Entry<K,V> subHigher(K key) { return absHigher(key); }
	1765	TreeMap.Entry<K,V> subFloor(K key) { return absFloor(key); }
	1766	TreeMap.Entry<K,V> subLower(K key) { return absLower(key); }
	1767	}
	1768
	1769	/**
	1770	* @serial include
	1771	*/
	1772	static final class DescendingSubMap<K,V> extends NavigableSubMap<K,V> {
	1773	private static final long serialVersionUID = 912986545866120460L;
	1774	DescendingSubMap(TreeMap<K,V> m,
	1775	boolean fromStart, K lo, boolean loInclusive,
	1776	boolean toEnd, K hi, boolean hiInclusive) {
	1777	super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
	1778	}
	1779
	1780	private final Comparator<? super K> reverseComparator =
	1781	Collections.reverseOrder(m.comparator);
	1782
	1783	public Comparator<? super K> comparator() {
	1784	return reverseComparator;
	1785	}
	1786
	1787	public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
	1788	K toKey, boolean toInclusive) {
	1789	if (!inRange(fromKey, fromInclusive))
	1790	throw new IllegalArgumentException("fromKey out of range");
	1791	if (!inRange(toKey, toInclusive))
	1792	throw new IllegalArgumentException("toKey out of range");
	1793	return new DescendingSubMap(m,
	1794	false, toKey, toInclusive,
	1795	false, fromKey, fromInclusive);
	1796	}
	1797
	1798	public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
	1799	if (!inRange(toKey, inclusive))
	1800	throw new IllegalArgumentException("toKey out of range");
	1801	return new DescendingSubMap(m,
	1802	false, toKey, inclusive,
	1803	toEnd, hi, hiInclusive);
	1804	}
	1805
	1806	public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
	1807	if (!inRange(fromKey, inclusive))
	1808	throw new IllegalArgumentException("fromKey out of range");
	1809	return new DescendingSubMap(m,
	1810	fromStart, lo, loInclusive,
	1811	false, fromKey, inclusive);
	1812	}
	1813
	1814	public NavigableMap<K,V> descendingMap() {
	1815	NavigableMap<K,V> mv = descendingMapView;
	1816	return (mv != null) ? mv :
	1817	(descendingMapView =
	1818	new AscendingSubMap(m,
	1819	fromStart, lo, loInclusive,
	1820	toEnd, hi, hiInclusive));
	1821	}
	1822
	1823	Iterator<K> keyIterator() {
	1824	return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
	1825	}
	1826
	1827	Iterator<K> descendingKeyIterator() {
	1828	return new SubMapKeyIterator(absLowest(), absHighFence());
	1829	}
	1830
	1831	final class DescendingEntrySetView extends EntrySetView {
	1832	public Iterator<Map.Entry<K,V>> iterator() {
	1833	return new DescendingSubMapEntryIterator(absHighest(), absLowFence());
	1834	}
	1835	}
	1836
	1837	public Set<Map.Entry<K,V>> entrySet() {
	1838	EntrySetView es = entrySetView;
	1839	return (es != null) ? es : new DescendingEntrySetView();
	1840	}
	1841
	1842	TreeMap.Entry<K,V> subLowest() { return absHighest(); }
	1843	TreeMap.Entry<K,V> subHighest() { return absLowest(); }
	1844	TreeMap.Entry<K,V> subCeiling(K key) { return absFloor(key); }
	1845	TreeMap.Entry<K,V> subHigher(K key) { return absLower(key); }
	1846	TreeMap.Entry<K,V> subFloor(K key) { return absCeiling(key); }
	1847	TreeMap.Entry<K,V> subLower(K key) { return absHigher(key); }
	1848	}
	1849
	1850	/**
	1851	* This class exists solely for the sake of serialization
	1852	* compatibility with previous releases of TreeMap that did not
	1853	* support NavigableMap. It translates an old-version SubMap into
	1854	* a new-version AscendingSubMap. This class is never otherwise
	1855	* used.
	1856	*
	1857	* @serial include
	1858	*/
	1859	private class SubMap extends AbstractMap<K,V>
	1860	implements SortedMap<K,V>, java.io.Serializable {
	1861	private static final long serialVersionUID = -6520786458950516097L;
	1862	private boolean fromStart = false, toEnd = false;
	1863	private K fromKey, toKey;
	1864	private Object readResolve() {
	1865	return new AscendingSubMap(TreeMap.this,
	1866	fromStart, fromKey, true,
	1867	toEnd, toKey, false);
	1868	}
	1869	public Set<Map.Entry<K,V>> entrySet() { throw new InternalError(); }
	1870	public K lastKey() { throw new InternalError(); }
	1871	public K firstKey() { throw new InternalError(); }
	1872	public SortedMap<K,V> subMap(K fromKey, K toKey) { throw new InternalError(); }
	1873	public SortedMap<K,V> headMap(K toKey) { throw new InternalError(); }
	1874	public SortedMap<K,V> tailMap(K fromKey) { throw new InternalError(); }
	1875	public Comparator<? super K> comparator() { throw new InternalError(); }
	1876	}
	1877
	1878
	1879	// Red-black mechanics
	1880
	1881	private static final boolean RED = false;
	1882	private static final boolean BLACK = true;
	1883
	1884	/**
	1885	* Node in the Tree. Doubles as a means to pass key-value pairs back to
	1886	* user (see Map.Entry).
	1887	*/
	1888
	1889	static final class Entry<K,V> implements Map.Entry<K,V> {
	1890	K key;
	1891	V value;
	1892	Entry<K,V> left = null;
	1893	Entry<K,V> right = null;
	1894	Entry<K,V> parent;
	1895	boolean color = BLACK;
	1896
	1897	/**
	1898	* Make a new cell with given key, value, and parent, and with
	1899	* {@code null} child links, and BLACK color.
	1900	*/
	1901	Entry(K key, V value, Entry<K,V> parent) {
	1902	this.key = key;
	1903	this.value = value;
	1904	this.parent = parent;
	1905	}
	1906
	1907	/**
	1908	* Returns the key.
	1909	*
	1910	* @return the key
	1911	*/
	1912	public K getKey() {
	1913	return key;
	1914	}
	1915
	1916	/**
	1917	* Returns the value associated with the key.
	1918	*
	1919	* @return the value associated with the key
	1920	*/
	1921	public V getValue() {
	1922	return value;
	1923	}
	1924
	1925	/**
	1926	* Replaces the value currently associated with the key with the given
	1927	* value.
	1928	*
	1929	* @return the value associated with the key before this method was
	1930	* called
	1931	*/
	1932	public V setValue(V value) {
	1933	V oldValue = this.value;
	1934	this.value = value;
	1935	return oldValue;
	1936	}
	1937
	1938	public boolean equals(Object o) {
	1939	if (!(o instanceof Map.Entry))
	1940	return false;
	1941	Map.Entry<?,?> e = (Map.Entry<?,?>)o;
	1942
	1943	return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
	1944	}
	1945
	1946	public int hashCode() {
	1947	int keyHash = (key==null ? 0 : key.hashCode());
	1948	int valueHash = (value==null ? 0 : value.hashCode());
	1949	return keyHash ^ valueHash;
	1950	}
	1951
	1952	public String toString() {
	1953	return key + "=" + value;
	1954	}
	1955	}
	1956
	1957	/**
	1958	* Returns the first Entry in the TreeMap (according to the TreeMap's
	1959	* key-sort function). Returns null if the TreeMap is empty.
	1960	*/
	1961	final Entry<K,V> getFirstEntry() {
	1962	Entry<K,V> p = root;
	1963	if (p != null)
	1964	while (p.left != null)
	1965	p = p.left;
	1966	return p;
	1967	}
	1968
	1969	/**
	1970	* Returns the last Entry in the TreeMap (according to the TreeMap's
	1971	* key-sort function). Returns null if the TreeMap is empty.
	1972	*/
	1973	final Entry<K,V> getLastEntry() {
	1974	Entry<K,V> p = root;
	1975	if (p != null)
	1976	while (p.right != null)
	1977	p = p.right;
	1978	return p;
	1979	}
	1980
	1981	/**
	1982	* Returns the successor of the specified Entry, or null if no such.
	1983	*/
	1984	static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
	1985	if (t == null)
	1986	return null;
	1987	else if (t.right != null) {
	1988	Entry<K,V> p = t.right;
	1989	while (p.left != null)
	1990	p = p.left;
	1991	return p;
	1992	} else {
	1993	Entry<K,V> p = t.parent;
	1994	Entry<K,V> ch = t;
	1995	while (p != null && ch == p.right) {
	1996	ch = p;
	1997	p = p.parent;
	1998	}
	1999	return p;
	2000	}
	2001	}
	2002
	2003	/**
	2004	* Returns the predecessor of the specified Entry, or null if no such.
	2005	*/
	2006	static <K,V> Entry<K,V> predecessor(Entry<K,V> t) {
	2007	if (t == null)
	2008	return null;
	2009	else if (t.left != null) {
	2010	Entry<K,V> p = t.left;
	2011	while (p.right != null)
	2012	p = p.right;
	2013	return p;
	2014	} else {
	2015	Entry<K,V> p = t.parent;
	2016	Entry<K,V> ch = t;
	2017	while (p != null && ch == p.left) {
	2018	ch = p;
	2019	p = p.parent;
	2020	}
	2021	return p;
	2022	}
	2023	}
	2024
	2025	/**
	2026	* Balancing operations.
	2027	*
	2028	* Implementations of rebalancings during insertion and deletion are
	2029	* slightly different than the CLR version. Rather than using dummy
	2030	* nilnodes, we use a set of accessors that deal properly with null. They
	2031	* are used to avoid messiness surrounding nullness checks in the main
	2032	* algorithms.
	2033	*/
	2034
	2035	private static <K,V> boolean colorOf(Entry<K,V> p) {
	2036	return (p == null ? BLACK : p.color);
	2037	}
	2038
	2039	private static <K,V> Entry<K,V> parentOf(Entry<K,V> p) {
	2040	return (p == null ? null: p.parent);
	2041	}
	2042
	2043	private static <K,V> void setColor(Entry<K,V> p, boolean c) {
	2044	if (p != null)
	2045	p.color = c;
	2046	}
	2047
	2048	private static <K,V> Entry<K,V> leftOf(Entry<K,V> p) {
	2049	return (p == null) ? null: p.left;
	2050	}
	2051
	2052	private static <K,V> Entry<K,V> rightOf(Entry<K,V> p) {
	2053	return (p == null) ? null: p.right;
	2054	}
	2055
	2056	/** From CLR */
	2057	private void rotateLeft(Entry<K,V> p) {
	2058	if (p != null) {
	2059	Entry<K,V> r = p.right;
	2060	p.right = r.left;
	2061	if (r.left != null)
	2062	r.left.parent = p;
	2063	r.parent = p.parent;
	2064	if (p.parent == null)
	2065	root = r;
	2066	else if (p.parent.left == p)
	2067	p.parent.left = r;
	2068	else
	2069	p.parent.right = r;
	2070	r.left = p;
	2071	p.parent = r;
	2072	}
	2073	}
	2074
	2075	/** From CLR */
	2076	private void rotateRight(Entry<K,V> p) {
	2077	if (p != null) {
	2078	Entry<K,V> l = p.left;
	2079	p.left = l.right;
	2080	if (l.right != null) l.right.parent = p;
	2081	l.parent = p.parent;
	2082	if (p.parent == null)
	2083	root = l;
	2084	else if (p.parent.right == p)
	2085	p.parent.right = l;
	2086	else p.parent.left = l;
	2087	l.right = p;
	2088	p.parent = l;
	2089	}
	2090	}
	2091
	2092	/** From CLR */
	2093	private void fixAfterInsertion(Entry<K,V> x) {
	2094	x.color = RED;
	2095
	2096	while (x != null && x != root && x.parent.color == RED) {
	2097	if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
	2098	Entry<K,V> y = rightOf(parentOf(parentOf(x)));
	2099	if (colorOf(y) == RED) {
	2100	setColor(parentOf(x), BLACK);
	2101	setColor(y, BLACK);
	2102	setColor(parentOf(parentOf(x)), RED);
	2103	x = parentOf(parentOf(x));
	2104	} else {
	2105	if (x == rightOf(parentOf(x))) {
	2106	x = parentOf(x);
	2107	rotateLeft(x);
	2108	}
	2109	setColor(parentOf(x), BLACK);
	2110	setColor(parentOf(parentOf(x)), RED);
	2111	rotateRight(parentOf(parentOf(x)));
	2112	}
	2113	} else {
	2114	Entry<K,V> y = leftOf(parentOf(parentOf(x)));
	2115	if (colorOf(y) == RED) {
	2116	setColor(parentOf(x), BLACK);
	2117	setColor(y, BLACK);
	2118	setColor(parentOf(parentOf(x)), RED);
	2119	x = parentOf(parentOf(x));
	2120	} else {
	2121	if (x == leftOf(parentOf(x))) {
	2122	x = parentOf(x);
	2123	rotateRight(x);
	2124	}
	2125	setColor(parentOf(x), BLACK);
	2126	setColor(parentOf(parentOf(x)), RED);
	2127	rotateLeft(parentOf(parentOf(x)));
	2128	}
	2129	}
	2130	}
	2131	root.color = BLACK;
	2132	}
	2133
	2134	/**
	2135	* Delete node p, and then rebalance the tree.
	2136	*/
	2137	private void deleteEntry(Entry<K,V> p) {
	2138	modCount++;
	2139	size--;
	2140
	2141	// If strictly internal, copy successor's element to p and then make p
	2142	// point to successor.
	2143	if (p.left != null && p.right != null) {
	2144	Entry<K,V> s = successor(p);
	2145	p.key = s.key;
	2146	p.value = s.value;
	2147	p = s;
	2148	} // p has 2 children
	2149
	2150	// Start fixup at replacement node, if it exists.
	2151	Entry<K,V> replacement = (p.left != null ? p.left : p.right);
	2152
	2153	if (replacement != null) {
	2154	// Link replacement to parent
	2155	replacement.parent = p.parent;
	2156	if (p.parent == null)
	2157	root = replacement;
	2158	else if (p == p.parent.left)
	2159	p.parent.left = replacement;
	2160	else
	2161	p.parent.right = replacement;
	2162
	2163	// Null out links so they are OK to use by fixAfterDeletion.
	2164	p.left = p.right = p.parent = null;
	2165
	2166	// Fix replacement
	2167	if (p.color == BLACK)
	2168	fixAfterDeletion(replacement);
	2169	} else if (p.parent == null) { // return if we are the only node.
	2170	root = null;
	2171	} else { // No children. Use self as phantom replacement and unlink.
	2172	if (p.color == BLACK)
	2173	fixAfterDeletion(p);
	2174
	2175	if (p.parent != null) {
	2176	if (p == p.parent.left)
	2177	p.parent.left = null;
	2178	else if (p == p.parent.right)
	2179	p.parent.right = null;
	2180	p.parent = null;
	2181	}
	2182	}
	2183	}
	2184
	2185	/** From CLR */
	2186	private void fixAfterDeletion(Entry<K,V> x) {
	2187	while (x != root && colorOf(x) == BLACK) {
	2188	if (x == leftOf(parentOf(x))) {
	2189	Entry<K,V> sib = rightOf(parentOf(x));
	2190
	2191	if (colorOf(sib) == RED) {
	2192	setColor(sib, BLACK);
	2193	setColor(parentOf(x), RED);
	2194	rotateLeft(parentOf(x));
	2195	sib = rightOf(parentOf(x));
	2196	}
	2197
	2198	if (colorOf(leftOf(sib)) == BLACK &&
	2199	colorOf(rightOf(sib)) == BLACK) {
	2200	setColor(sib, RED);
	2201	x = parentOf(x);
	2202	} else {
	2203	if (colorOf(rightOf(sib)) == BLACK) {
	2204	setColor(leftOf(sib), BLACK);
	2205	setColor(sib, RED);
	2206	rotateRight(sib);
	2207	sib = rightOf(parentOf(x));
	2208	}
	2209	setColor(sib, colorOf(parentOf(x)));
	2210	setColor(parentOf(x), BLACK);
	2211	setColor(rightOf(sib), BLACK);
	2212	rotateLeft(parentOf(x));
	2213	x = root;
	2214	}
	2215	} else { // symmetric
	2216	Entry<K,V> sib = leftOf(parentOf(x));
	2217
	2218	if (colorOf(sib) == RED) {
	2219	setColor(sib, BLACK);
	2220	setColor(parentOf(x), RED);
	2221	rotateRight(parentOf(x));
	2222	sib = leftOf(parentOf(x));
	2223	}
	2224
	2225	if (colorOf(rightOf(sib)) == BLACK &&
	2226	colorOf(leftOf(sib)) == BLACK) {
	2227	setColor(sib, RED);
	2228	x = parentOf(x);
	2229	} else {
	2230	if (colorOf(leftOf(sib)) == BLACK) {
	2231	setColor(rightOf(sib), BLACK);
	2232	setColor(sib, RED);
	2233	rotateLeft(sib);
	2234	sib = leftOf(parentOf(x));
	2235	}
	2236	setColor(sib, colorOf(parentOf(x)));
	2237	setColor(parentOf(x), BLACK);
	2238	setColor(leftOf(sib), BLACK);
	2239	rotateRight(parentOf(x));
	2240	x = root;
	2241	}
	2242	}
	2243	}
	2244
	2245	setColor(x, BLACK);
	2246	}
	2247
	2248	private static final long serialVersionUID = 919286545866124006L;
	2249
	2250	/**
	2251	* Save the state of the {@code TreeMap} instance to a stream (i.e.,
	2252	* serialize it).
	2253	*
	2254	* @serialData The <em>size</em> of the TreeMap (the number of key-value
	2255	* mappings) is emitted (int), followed by the key (Object)
	2256	* and value (Object) for each key-value mapping represented
	2257	* by the TreeMap. The key-value mappings are emitted in
	2258	* key-order (as determined by the TreeMap's Comparator,
	2259	* or by the keys' natural ordering if the TreeMap has no
	2260	* Comparator).
	2261	*/
	2262	private void writeObject(java.io.ObjectOutputStream s)
	2263	throws java.io.IOException {
	2264	// Write out the Comparator and any hidden stuff
	2265	s.defaultWriteObject();
	2266
	2267	// Write out size (number of Mappings)
	2268	s.writeInt(size);
	2269
	2270	// Write out keys and values (alternating)
	2271	for (Iterator<Map.Entry<K,V>> i = entrySet().iterator(); i.hasNext(); ) {
	2272	Map.Entry<K,V> e = i.next();
	2273	s.writeObject(e.getKey());
	2274	s.writeObject(e.getValue());
	2275	}
	2276	}
	2277
	2278	/**
	2279	* Reconstitute the {@code TreeMap} instance from a stream (i.e.,
	2280	* deserialize it).
	2281	*/
	2282	private void readObject(final java.io.ObjectInputStream s)
	2283	throws java.io.IOException, ClassNotFoundException {
	2284	// Read in the Comparator and any hidden stuff
	2285	s.defaultReadObject();
	2286
	2287	// Read in size
	2288	int size = s.readInt();
	2289
	2290	buildFromSorted(size, null, s, null);
	2291	}
	2292
	2293	/** Intended to be called only from TreeSet.readObject */
	2294	void readTreeSet(int size, java.io.ObjectInputStream s, V defaultVal)
	2295	throws java.io.IOException, ClassNotFoundException {
	2296	buildFromSorted(size, null, s, defaultVal);
	2297	}
	2298
	2299	/** Intended to be called only from TreeSet.addAll */
	2300	void addAllForTreeSet(SortedSet<? extends K> set, V defaultVal) {
	2301	try {
	2302	buildFromSorted(set.size(), set.iterator(), null, defaultVal);
	2303	} catch (java.io.IOException cannotHappen) {
	2304	} catch (ClassNotFoundException cannotHappen) {
	2305	}
	2306	}
	2307
	2308
	2309	/**
	2310	* Linear time tree building algorithm from sorted data. Can accept keys
	2311	* and/or values from iterator or stream. This leads to too many
	2312	* parameters, but seems better than alternatives. The four formats
	2313	* that this method accepts are:
	2314	*
	2315	* 1) An iterator of Map.Entries. (it != null, defaultVal == null).
	2316	* 2) An iterator of keys. (it != null, defaultVal != null).
	2317	* 3) A stream of alternating serialized keys and values.
	2318	* (it == null, defaultVal == null).
	2319	* 4) A stream of serialized keys. (it == null, defaultVal != null).
	2320	*
	2321	* It is assumed that the comparator of the TreeMap is already set prior
	2322	* to calling this method.
	2323	*
	2324	* @param size the number of keys (or key-value pairs) to be read from
	2325	* the iterator or stream
	2326	* @param it If non-null, new entries are created from entries
	2327	* or keys read from this iterator.
	2328	* @param str If non-null, new entries are created from keys and
	2329	* possibly values read from this stream in serialized form.
	2330	* Exactly one of it and str should be non-null.
	2331	* @param defaultVal if non-null, this default value is used for
	2332	* each value in the map. If null, each value is read from
	2333	* iterator or stream, as described above.
	2334	* @throws IOException propagated from stream reads. This cannot
	2335	* occur if str is null.
	2336	* @throws ClassNotFoundException propagated from readObject.
	2337	* This cannot occur if str is null.
	2338	*/
	2339	private void buildFromSorted(int size, Iterator it,
	2340	java.io.ObjectInputStream str,
	2341	V defaultVal)
	2342	throws java.io.IOException, ClassNotFoundException {
	2343	this.size = size;
	2344	root = buildFromSorted(0, 0, size-1, computeRedLevel(size),
	2345	it, str, defaultVal);
	2346	}
	2347
	2348	/**
	2349	* Recursive "helper method" that does the real work of the
	2350	* previous method. Identically named parameters have
	2351	* identical definitions. Additional parameters are documented below.
	2352	* It is assumed that the comparator and size fields of the TreeMap are
	2353	* already set prior to calling this method. (It ignores both fields.)
	2354	*
	2355	* @param level the current level of tree. Initial call should be 0.
	2356	* @param lo the first element index of this subtree. Initial should be 0.
	2357	* @param hi the last element index of this subtree. Initial should be
	2358	* size-1.
	2359	* @param redLevel the level at which nodes should be red.
	2360	* Must be equal to computeRedLevel for tree of this size.
	2361	*/
	2362	private final Entry<K,V> buildFromSorted(int level, int lo, int hi,
	2363	int redLevel,
	2364	Iterator it,
	2365	java.io.ObjectInputStream str,
	2366	V defaultVal)
	2367	throws java.io.IOException, ClassNotFoundException {
	2368	/*
	2369	* Strategy: The root is the middlemost element. To get to it, we
	2370	* have to first recursively construct the entire left subtree,
	2371	* so as to grab all of its elements. We can then proceed with right
	2372	* subtree.
	2373	*
	2374	* The lo and hi arguments are the minimum and maximum
	2375	* indices to pull out of the iterator or stream for current subtree.
	2376	* They are not actually indexed, we just proceed sequentially,
	2377	* ensuring that items are extracted in corresponding order.
	2378	*/
	2379
	2380	if (hi < lo) return null;
	2381
	2382	int mid = (lo + hi) >>> 1;
	2383
	2384	Entry<K,V> left = null;
	2385	if (lo < mid)
	2386	left = buildFromSorted(level+1, lo, mid - 1, redLevel,
	2387	it, str, defaultVal);
	2388
	2389	// extract key and/or value from iterator or stream
	2390	K key;
	2391	V value;
	2392	if (it != null) {
	2393	if (defaultVal==null) {
	2394	Map.Entry<K,V> entry = (Map.Entry<K,V>)it.next();
	2395	key = entry.getKey();
	2396	value = entry.getValue();
	2397	} else {
	2398	key = (K)it.next();
	2399	value = defaultVal;
	2400	}
	2401	} else { // use stream
	2402	key = (K) str.readObject();
	2403	value = (defaultVal != null ? defaultVal : (V) str.readObject());
	2404	}
	2405
	2406	Entry<K,V> middle = new Entry<>(key, value, null);
	2407
	2408	// color nodes in non-full bottommost level red
	2409	if (level == redLevel)
	2410	middle.color = RED;
	2411
	2412	if (left != null) {
	2413	middle.left = left;
	2414	left.parent = middle;
	2415	}
	2416
	2417	if (mid < hi) {
	2418	Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,
	2419	it, str, defaultVal);
	2420	middle.right = right;
	2421	right.parent = middle;
	2422	}
	2423
	2424	return middle;
	2425	}
	2426
	2427	/**
	2428	* Find the level down to which to assign all nodes BLACK. This is the
	2429	* last `full' level of the complete binary tree produced by
	2430	* buildTree. The remaining nodes are colored RED. (This makes a `nice'
	2431	* set of color assignments wrt future insertions.) This level number is
	2432	* computed by finding the number of splits needed to reach the zeroeth
	2433	* node. (The answer is ~lg(N), but in any case must be computed by same
	2434	* quick O(lg(N)) loop.)
	2435	*/
	2436	private static int computeRedLevel(int sz) {
	2437	int level = 0;
	2438	for (int m = sz - 1; m >= 0; m = m / 2 - 1)
	2439	level++;
	2440	return level;
	2441	}
	2442	}