gcc/libjava/java/util/IdentityHashMap.java
Bryce McKinlay d9fd7154ec Collections drop from Classpath:
2001-12-15  Bryce McKinlay  <bryce@waitaki.otago.ac.nz>

	* java/util/BitSet.java (and): Fix off-by-one bug, don't skip part of
	the bitset.
	(andNot): Likewise.
	(xor): Likewise.

2001-12-15  Bryce McKinlay  <bryce@waitaki.otago.ac.nz>

	* java/util/LinkedList.java (LinkedListItr.add): Don't skip the next
	entry.

2001-12-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/TreeMap.java (removeNode): Fix bug in node removal.

2001-12-15  Bryce McKinlay  <bryce@waitaki.otago.ac.nz>

	* java/util/AbstractCollection.java (containsAll): Use size of the
	correct collection for loop bound.
	* java/util/AbstractList.java (iterator.next): Increment pos after
	calling get on backing list.
	(listIterator.next): Likewise.
	* java/util/LinkedList.java (addLastEntry): Don't increment size before
	checking for size == 0.
	(addFirstEntry): Rearrange to match addLastEntry.
	(add): Do not increment size before inserting the new entry.

	* java/util/AbstractCollection.java (addAll): Use size of the
	correct collection for loop bound.

2001-12-15  Bryce McKinlay  <bryce@waitaki.otago.ac.nz>

	* java/util/AbstractSet.java (removeAll): Fix scoping thinko.
	* java/util/HashMap.java (putAllInternal): Set size here.
	* java/util/Hashtable.java (putAllInternal): New method. Copy contents
	of a map efficiently without calling put() or putAll().
	(Hashtable (map)): Use putAllInternal.
	(clone): Likewise.

2001-12-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/Collections.java:
	* java/util/Vector.java:
	* java/util/WeakHashMap.java: Fix spelling errors.

2001-12-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/AbstractCollection.java (removeAllInternal),
	(retainAllInternal): Add hooks for use by ArrayList.
	* java/util/AbstractList.java: Minor code updates. Fix some
	scoping.
	* java/util/AbstractMap.java: ditto
	* java/util/ArrayList.java (readObject, writeObject): ditto
	(removeAllInternal, retainAllInternal): Optimize.
	* java/util/Arrays.java: ditto
	* java/util/Collections.java: ditto. Change order of parameters
	to equals(Object, Object) to match specs.
	* java/util/Dictionary.java: Improve javadoc.
	(Dictionary): Add explicit constructor.
	* java/util/HashMap.java: Improve javadoc. Rearrange methods to
	follow order in JDK. Cleanups related to recent code migration to
	AbstractMap. Fix some scoping.
	(entrySet): Cache the result.
	(modCount): Ensure that this is updated correctly.
	* java/util/HashSet.java: Improve javadoc. Fix some scoping.
	(init): Add hooks for LinkedHashSet.
	(map): Use "" instead of Boolean.TRUE in backing map. Use
	package-private API where possible for less overhead.
	(readObject, writeObject): Fix serialization.
	* java/util/Hashtable.java: Improve javadoc. Fix some scoping.
	(entrySet, keySet, values): Cache the result.
	(modCount): Ensure that this is updated correctly.
	(contains, remove): Fix NullPointer checking to match specs.
	(class Enumeration): Make more like HashIterator.
	* java/util/IdentityHashMap.java: Minor code updates.
	(modCount): Ensure that this is updated correctly.
	(readObject, writeObject): Fix serialization.
	* java/util/LinkedHashMap.java: Minor code updates. Cleanups
	related to recent code migration to AbstractMap.
	* java/util/LinkedHashSet.java: New file.
	* java/util/LinkedList.java:
	(readObject, writeObject): Fix serialization.
	* java/util/Makefile.am: List recently added files.
	* java/util/Stack.java: Minor code updates.
	* java/util/TreeMap.java: Improve javadoc. Overhaul the class to
	be more efficient. Fix some scoping. Rearrange the methods.
	(nil): Ensure that this can be thread-safe, and make it a static
	final. Initialize it to be more useful as a sentinal node.
	(Node): Specify color in constructor.
	(deleteFixup, insertFixup): Improve comments and algorithm.
	(fabricateTree): Redesign with less overhead.
	(lowestGreaterThan): Add parameter first to make SubMap easier.
	(removeNode): Patch hole where nil was being modified. Choose
	predecessor instead of successor so in-place swap works.
	(class VerifyResult, verifyTree, verifySub, verifyError): Remove
	this dead code after verifying the class works.
	(class SubMap): Rewrite several algorithms to avoid problems with
	comparing nil.
	* java/util/TreeSet.java: Improve javadoc. Fix some scoping.
	(clone): Fix ClassCastException when cloning subSet().
	(readObject, writeObject): Fix serialization.
	* java/util/WeakHashMap.java: Improve javadoc. Fix some scoping.
	(NULL_KEY): Make it compare as null, for ease elsewhere.
	(Class WeakEntry): Rename from Entry, to avoid shadowing
	Map.Entry. Add missing toString.
	(modCount): Ensure that this is updated correctly.
	(clear, containsValue, keySet, putAll, values, WeakHashMap(Map)):
	Add missing methods and constructor.

2001-12-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/ArrayList.java (checkBoundExclusive),
	(checkBoundInclusive): Rename from range??clusive, to match
	AbstractList.
	* java/util/LinkedList.java (checkBoundsExclusive),
	(checkBoundsInclusive): ditto
	* java/util/Vector.java (checkBoundExclusive),
	(checkBoundInclusive): Move bounds checking into common methods.

2001-12-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/AbstractList.java:
	(modCount): Make sure it is updated in all needed places.
	* java/util/ArrayList.java: Improve javadoc. Implements
	RandomAccess. Add serialVersionUID. Reorder methods.
	(modCount): Make sure it is updated in all needed places.
	(rangeExclusive, rangeInclusive): Add common methods for bounds
	check.
	(isEmpty): Add missing method.
	* java/util/Collections.java: (class SynchronizedList): Make
	package visible.
	* java/util/ConcurrentModificationException.java: Improve
	javadoc.
	* java/util/EmptyStackException.java: Improve javadoc.
	* java/util/LinkedList.java: Improve javadoc.
	(modCount): Make sure it is updated in all needed places.
	(rangeExclusive, rangeInclusive): Add common methods for bounds
	check.
	* java/util/NoSuchElementException.java: Improve javadoc.
	* java/util/Stack.java: Improve javadoc. Fix synchronization
	issues.
	(modCount): Make sure it is updated in all needed places.
	* java/util/Vector.java: Improve javadoc. Fix synchronization
	issues. Implements RandomAccess. Reorder methods.
	(modCount): Make sure it is updated in all needed places.
	(setSize): Fix according to specifications: this does not dictate
	the backing array size.
	(removeAll, retainAll): Faster implementations.

2001-12-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/BitSet.java: Improve javadoc.
	(cardinality(), clear(), clear(int, int), flip(int)),
	(flip(int, int), get(int, int), intersects(BitSet), isEmpty()),
	(nextClearBit(int), nextSetBit(int), set(int, boolean)),
	(set(int, int), set(int, int, boolean)): Add new JDK 1.4 methods.
	(clone): Fix so subclasses clone correctly.

2001-12-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/AbstractCollection.java: Improve javadoc.
	(AbstractCollection()): Make constructor protected.
	(equals(Object, Object), hashCode(Object)): Add utility methods.
	* java/util/AbstractList.java: Improve javadoc.
	(AbstractList()): Make constructor protected.
	(indexOf(Object)): Call listIterator(), not listIterator(int).
	(iterator()): Follow Sun's requirement to not use listIterator(0).
	(listIterator(int)): Make AbstractListItr anonymous.
	(subList(int, int)): Add support for RandomAccess.
	(SubList.add(int, Object), SubList.remove(Object)): Fix bug with
	modCount tracking.
	(SubList.addAll(Collection)): Add missing method.
	(SubList.listIterator(int)): Fix bugs in indexing, modCount
	tracking.
	(class RandomAccessSubList): Add new class.
	* java/util/AbstractMap.java: Improve javadoc.
	(keys, values, KEYS, VALUES, ENTRIES): Consolidate common map
	fields.
	(AbstractMap()): Make constructor protected.
	(equals(Object, Object), hashCode(Object)): Add utility methods.
	(equals(Object)): Change algorithm to
	entrySet().equals(m.entrySet()), as documented by Sun.
	(keySet(), values()): Cache the collections.
	* java/util/AbstractSequentialList.java: Improve javadoc.
	(AbstractSequentialList()): Make constructor protected.
	* java/util/AbstractSet.java: Improve javadoc.
	(AbstractSet()): Make constructor protected.
	(removeAll(Collection)): Add missing method.
	* java/util/Arrays.java: Improve javadoc, rearrange method orders.
	(defaultComparator): Remove, in favor of
	Collections.compare(Object, Object, Comparator).
	(binarySearch, equals, sort): Fix natural order comparison of
	floats and doubles. Also improve Object comparison - when
	comparator is null, use natural order.
	(fill, sort): Add missing checks for IllegalArgumentException.
	(sort, qsort): Fix sorting bugs, rework the code for more
	legibility.
	(mergeSort): Inline into sort(Object[], int, int, Comparator).
	(class ArrayList): Rename from ListImpl, and make compatible with
	JDK serialization. Add methods which more efficiently override
	those of AbstractList.
	* java/util/Collections: Improve javadoc.
	(isSequential(List)): Add and use a method for deciding between
	RandomAccess and sequential algorithms on lists.
	(class Empty*, class Synchronized*, class Unmodifiable*): Make
	compliant with JDK serializability.
	(class Singleton*, class CopiesList, class RevereseComparator),
	(class UnmodifiableMap.UnmodifiableEntrySet),
	(class *RandomAccessList): New classes for serial compatibility.
	(class Empty*, class Singleton*, class CopiesList): Add methods
	which more efficiently override those of Abstract*.
	(search): Inline into binarySearch(List, Object, Comparator).
	(binarySearch): Make sequential search only do log(n) comparisons,
	instead of n.
	(copy(List, List)): Do bounds checking before starting.
	(indexOfSubList, lastIndexOfSubList, list, replaceAll, rotate),
	(swap):	Add new JDK 1.4 methods.
	(binarySearch, max, min, sort): Allow null comparator to represent
	natural ordering.
	(reverse(List)): Avoid unnecessary swap.
	(shuffle(List, Random)): Do shuffle in-place for RandomAccess
	lists.
	(SingletonList.get): Fix logic bug.
	(SingletonMap.entrySet): Make the entry immutable, and cache the
	returned set.
	(SynchronizedCollection, SynchronizedMap, UnmodifiableCollection),
	(UnmodifiableMap): Detect null pointer in construction.
	(SynchronizedMap, UnmodifiableMap): Cache collection views.
	* java/util/BasicMapEntry: Improve javadoc.

From-SVN: r48035
2001-12-15 07:47:03 +00:00

919 lines
27 KiB
Java

/* IdentityHashMap.java -- a class providing a hashtable data structure,
mapping Object --> Object, which uses object identity for hashing.
Copyright (C) 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.util;
import java.io.*;
/**
* This class provides a hashtable-backed implementation of the
* Map interface, but uses object identity to do its hashing. In fact,
* it uses object identity for comparing values, as well. It uses a
* linear-probe hash table, which may have faster performance
* than the chaining employed by HashMap.
* <p>
*
* <em>WARNING: This is not a general purpose map. Because it uses
* System.identityHashCode and ==, instead of hashCode and equals, for
* comparison, it violated Map's general contract, and may cause
* undefined behavior when compared to other maps which are not
* IdentityHashMaps. This is designed only for the rare cases when
* identity semantics are needed.</em> An example use is
* topology-preserving graph transformations, such as deep cloning,
* or as proxy object mapping such as in debugging.
* <p>
*
* This map permits <code>null</code> keys and values, and does not
* guarantee that elements will stay in the same order over time. The
* basic operations (<code>get</code> and <code>put</code>) take
* constant time, provided System.identityHashCode is decent. You can
* tune the behavior by specifying the expected maximum size. As more
* elements are added, the map may need to allocate a larger table,
* which can be expensive.
* <p>
*
* This implementation is unsynchronized. If you want multi-thread
* access to be consistent, you must synchronize it, perhaps by using
* <code>Collections.synchronizedMap(new IdentityHashMap(...));</code>.
* The iterators are <i>fail-fast</i>, meaning that a structural modification
* made to the map outside of an iterator's remove method cause the
* iterator, and in the case of the entrySet, the Map.Entry, to
* fail with a {@link ConcurrentModificationException}.
*
* @author Tom Tromey <tromey@redhat.com>
* @author Eric Blake <ebb9@email.byu.edu>
* @see System#identityHashCode(Object)
* @see Collection
* @see Map
* @see HashMap
* @see TreeMap
* @see LinkedHashMap
* @see WeakHashMap
* @since 1.4
* @status updated to 1.4
*/
public class IdentityHashMap extends AbstractMap
implements Map, Serializable, Cloneable
{
/** The default capacity. */
private static final int DEFAULT_CAPACITY = 21;
/**
* This object is used to mark deleted items. Package visible for use by
* nested classes.
*/
static final Object tombstone = new Object();
/**
* This object is used to mark empty slots. We need this because
* using null is ambiguous. Package visible for use by nested classes.
*/
static final Object emptyslot = new Object();
/**
* Compatible with JDK 1.4.
*/
private static final long serialVersionUID = 8188218128353913216L;
/**
* The number of mappings in the table. Package visible for use by nested
* classes.
* @serial
*/
int size;
/**
* The table itself. Package visible for use by nested classes.
*/
transient Object[] table;
/**
* The number of structural modifications made so far. Package visible for
* use by nested classes.
*/
transient int modCount;
/**
* The cache for {@link #entrySet()}.
*/
private transient Set entries;
/**
* The threshold for rehashing, which is 75% of (table.length / 2).
*/
private transient int threshold;
/**
* Create a new IdentityHashMap with the default capacity (21 entries).
*/
public IdentityHashMap()
{
this(DEFAULT_CAPACITY);
}
/**
* Create a new IdentityHashMap with the indicated number of
* entries. If the number of elements added to this hash map
* exceeds this maximum, the map will grow itself; however, that
* incurs a performance penalty.
*
* @param max initial size
* @throws IllegalArgumentException if max is negative
*/
public IdentityHashMap(int max)
{
if (max < 0)
throw new IllegalArgumentException();
// Need at least two slots, or hash() will break.
if (max < 2)
max = 2;
table = new Object[2 * max];
Arrays.fill(table, emptyslot);
// This is automatically set.
// size = 0;
threshold = max / 4 * 3;
}
/**
* Create a new IdentityHashMap whose contents are taken from the
* given Map.
*
* @param m The map whose elements are to be put in this map
* @throws NullPointerException if m is null
*/
public IdentityHashMap(Map m)
{
this(Math.max(m.size() * 2, DEFAULT_CAPACITY));
putAll(m);
}
/**
* Remove all mappings from this map.
*/
public void clear()
{
if (size != 0)
{
modCount++;
Arrays.fill(table, emptyslot);
size = 0;
}
}
/**
* Creates a shallow copy where keys and values are not cloned.
*/
public Object clone()
{
try
{
IdentityHashMap copy = (IdentityHashMap) super.clone();
copy.table = (Object[]) table.clone();
copy.entries = null; // invalidate the cache
return copy;
}
catch (CloneNotSupportedException e)
{
// Can't happen.
return null;
}
}
/**
* Tests whether the specified key is in this map. Unlike normal Maps,
* this test uses <code>entry == key</code> instead of
* <code>entry == null ? key == null : entry.equals(key)</code>.
*
* @param key the key to look for
* @return true if the key is contained in the map
* @see #containsValue(Object)
* @see #get(Object)
*/
public boolean containsKey(Object key)
{
return key == table[hash(key)];
}
/**
* Returns true if this HashMap contains the value. Unlike normal maps,
* this test uses <code>entry == value</code> instead of
* <code>entry == null ? value == null : entry.equals(value)</code>.
*
* @param value the value to search for in this HashMap
* @return true if at least one key maps to the value
* @see #containsKey(Object)
*/
public boolean containsValue(Object value)
{
for (int i = table.length - 1; i > 0; i -= 2)
if (table[i] == value)
return true;
return false;
}
/**
* Returns a "set view" of this Map's entries. The set is backed by
* the Map, so changes in one show up in the other. The set supports
* element removal, but not element addition.
* <p>
*
* <em>The semantics of this set, and of its contained entries, are
* different from the contract of Set and Map.Entry in order to make
* IdentityHashMap work. This means that while you can compare these
* objects between IdentityHashMaps, comparing them with regular sets
* or entries is likely to have undefined behavior.</em> The entries
* in this set are reference-based, rather than the normal object
* equality. Therefore, <code>e1.equals(e2)</code> returns
* <code>e1.getKey() == e2.getKey() && e1.getValue() == e2.getValue()</code>,
* and <code>e.hashCode()</code> returns
* <code>System.identityHashCode(e.getKey()) ^
* System.identityHashCode(e.getValue())</code>.
* <p>
*
* Note that the iterators for all three views, from keySet(), entrySet(),
* and values(), traverse the Map in the same sequence.
*
* @return a set view of the entries
* @see #keySet()
* @see #values()
* @see Map.Entry
*/
public Set entrySet()
{
if (entries == null)
entries = new AbstractSet()
{
public int size()
{
return size;
}
public Iterator iterator()
{
return new IdentityIterator(ENTRIES);
}
public void clear()
{
IdentityHashMap.this.clear();
}
public boolean contains(Object o)
{
if (! (o instanceof Map.Entry))
return false;
Map.Entry m = (Map.Entry) o;
return m.getValue() == table[hash(m.getKey()) + 1];
}
public int hashCode()
{
return IdentityHashMap.this.hashCode();
}
public boolean remove(Object o)
{
if (! (o instanceof Map.Entry))
return false;
Object key = ((Map.Entry) o).getKey();
int h = hash(key);
if (table[h] == key)
{
size--;
modCount++;
table[h] = tombstone;
table[h + 1] = tombstone;
return true;
}
return false;
}
};
return entries;
}
/**
* Compares two maps for equality. This returns true only if both maps
* have the same reference-identity comparisons. While this returns
* <code>this.entrySet().equals(m.entrySet())</code> as specified by Map,
* this will not work with normal maps, since the entry set compares
* with == instead of .equals.
*
* @param o the object to compare to
* @return true if it is equal
*/
public boolean equals(Object o)
{
// Why did Sun specify this one? The superclass does the right thing.
return super.equals(o);
}
/**
* Return the value in this Map associated with the supplied key,
* or <pre>null</pre> if the key maps to nothing. NOTE: Since the value
* could also be null, you must use containsKey to see if this key
* actually maps to something. Unlike normal maps, this tests for the key
* with <code>entry == key</code> instead of
* <code>entry == null ? key == null : entry.equals(key)</code>.
*
* @param key the key for which to fetch an associated value
* @return what the key maps to, if present
* @see #put(Object, Object)
* @see #containsKey(Object)
*/
public Object get(Object key)
{
int h = hash(key);
return table[h] == key ? table[h + 1] : null;
}
/**
* Returns the hashcode of this map. This guarantees that two
* IdentityHashMaps that compare with equals() will have the same hash code,
* but may break with comparison to normal maps since it uses
* System.identityHashCode() instead of hashCode().
*
* @return the hash code
*/
public int hashCode()
{
int hash = 0;
for (int i = table.length - 2; i >= 0; i -= 2)
{
Object key = table[i];
if (key == emptyslot || key == tombstone)
continue;
hash += (System.identityHashCode(key)
^ System.identityHashCode(table[i + 1]));
}
return hash;
}
/**
* Returns true if there are no key-value mappings currently in this Map
* @return <code>size() == 0</code>
*/
public boolean isEmpty()
{
return size == 0;
}
/**
* Returns a "set view" of this Map's keys. The set is backed by the
* Map, so changes in one show up in the other. The set supports
* element removal, but not element addition.
* <p>
*
* <em>The semantics of this set are different from the contract of Set
* in order to make IdentityHashMap work. This means that while you can
* compare these objects between IdentityHashMaps, comparing them with
* regular sets is likely to have undefined behavior.</em> The hashCode
* of the set is the sum of the identity hash codes, instead of the
* regular hashCodes, and equality is determined by reference instead
* of by the equals method.
* <p>
*
* @return a set view of the keys
* @see #values()
* @see #entrySet()
*/
public Set keySet()
{
if (keys == null)
keys = new AbstractSet()
{
public int size()
{
return size;
}
public Iterator iterator()
{
return new IdentityIterator(KEYS);
}
public void clear()
{
IdentityHashMap.this.clear();
}
public boolean contains(Object o)
{
return containsKey(o);
}
public int hashCode()
{
int hash = 0;
for (int i = table.length - 2; i >= 0; i -= 2)
{
Object key = table[i];
if (key == emptyslot || key == tombstone)
continue;
hash += System.identityHashCode(key);
}
return hash;
}
public boolean remove(Object o)
{
int h = hash(o);
if (table[h] == o)
{
size--;
modCount++;
table[h] = tombstone;
table[h + 1] = tombstone;
return true;
}
return false;
}
};
return keys;
}
/**
* Puts the supplied value into the Map, mapped by the supplied key.
* The value may be retrieved by any object which <code>equals()</code>
* this key. NOTE: Since the prior value could also be null, you must
* first use containsKey if you want to see if you are replacing the
* key's mapping. Unlike normal maps, this tests for the key
* with <code>entry == key</code> instead of
* <code>entry == null ? key == null : entry.equals(key)</code>.
*
* @param key the key used to locate the value
* @param value the value to be stored in the HashMap
* @return the prior mapping of the key, or null if there was none
* @see #get(Object)
*/
public Object put(Object key, Object value)
{
// Rehash if the load factor is too high.
if (size > threshold)
{
Object[] old = table;
// This isn't necessarily prime, but it is an odd number of key/value
// slots, which has a higher probability of fewer collisions.
table = new Object[old.length * 2 + 2];
Arrays.fill(table, emptyslot);
size = 0;
threshold = table.length / 4 * 3;
for (int i = old.length - 2; i >= 0; i -= 2)
{
Object oldkey = old[i];
if (oldkey != tombstone && oldkey != emptyslot)
// Just use put. This isn't very efficient, but it is ok.
put(oldkey, old[i + 1]);
}
}
int h = hash(key);
if (table[h] == key)
{
Object r = table[h + 1];
table[h + 1] = value;
return r;
}
// At this point, we add a new mapping.
modCount++;
size++;
table[h] = key;
table[h + 1] = value;
return null;
}
/**
* Copies all of the mappings from the specified map to this. If a key
* is already in this map, its value is replaced.
*
* @param m the map to copy
* @throws NullPointerException if m is null
*/
public void putAll(Map m)
{
// Why did Sun specify this one? The superclass does the right thing.
super.putAll(m);
}
/**
* Removes from the HashMap and returns the value which is mapped by the
* supplied key. If the key maps to nothing, then the HashMap remains
* unchanged, and <pre>null</pre> is returned. NOTE: Since the value
* could also be null, you must use containsKey to see if you are
* actually removing a mapping. Unlike normal maps, this tests for the
* key with <code>entry == key</code> instead of
* <code>entry == null ? key == null : entry.equals(key)</code>.
*
* @param key the key used to locate the value to remove
* @return whatever the key mapped to, if present
*/
public Object remove(Object key)
{
int h = hash(key);
if (table[h] == key)
{
modCount++;
size--;
Object r = table[h + 1];
table[h] = tombstone;
table[h + 1] = tombstone;
return r;
}
return null;
}
/**
* Returns the number of kay-value mappings currently in this Map
* @return the size
*/
public int size()
{
return size;
}
/**
* Returns a "collection view" (or "bag view") of this Map's values.
* The collection is backed by the Map, so changes in one show up
* in the other. The collection supports element removal, but not element
* addition.
* <p>
*
* <em>The semantics of this set are different from the contract of
* Collection in order to make IdentityHashMap work. This means that
* while you can compare these objects between IdentityHashMaps, comparing
* them with regular sets is likely to have undefined behavior.</em>
* Likewise, contains and remove go by == instead of equals().
* <p>
*
* @return a bag view of the values
* @see #keySet()
* @see #entrySet()
*/
public Collection values()
{
if (values == null)
values = new AbstractCollection()
{
public int size()
{
return size;
}
public Iterator iterator()
{
return new IdentityIterator(VALUES);
}
public void clear()
{
IdentityHashMap.this.clear();
}
public boolean remove(Object o)
{
for (int i = table.length - 1; i > 0; i -= 2)
if (table[i] == o)
{
modCount++;
table[i - 1] = tombstone;
table[i] = tombstone;
size--;
return true;
}
return false;
}
};
return values;
}
/**
* Helper method which computes the hash code, then traverses the table
* until it finds the key, or the spot where the key would go.
*
* @param key the key to check
* @return the index where the key belongs
* @see #IdentityHashMap(int)
* @see #put(Object, Object)
*/
// Package visible for use by nested classes.
int hash(Object key)
{
// Implementation note: it is feasible for the table to have no
// emptyslots, if it is full with entries and tombstones, so we must
// remember where we started. If we encounter the key or an emptyslot,
// we are done. If we encounter a tombstone, the key may still be in
// the array. If we don't encounter the key, we use the first emptyslot
// or tombstone we encountered as the location where the key would go.
// By requiring at least 2 key/value slots, and rehashing at 75%
// capacity, we guarantee that there will always be either an emptyslot
// or a tombstone somewhere in the table.
int h = 2 * Math.abs(System.identityHashCode(key) % table.length);
int del = -1;
int save = h;
do
{
if (table[h] == key)
return h;
if (table[h] == emptyslot)
break;
if (table[h] == tombstone && del < 0)
del = h;
h -= 2;
if (h < 0)
h = table.length - 2;
}
while (h != save);
return del < 0 ? h : del;
}
/**
* This class allows parameterized iteration over IdentityHashMaps. Based
* on its construction, it returns the key or value of a mapping, or
* creates the appropriate Map.Entry object with the correct fail-fast
* semantics and identity comparisons.
*
* @author Tom Tromey <tromey@redhat.com>
* @author Eric Blake <ebb9@email.byu.edu>
*/
private final class IdentityIterator implements Iterator
{
/**
* The type of this Iterator: {@link #KEYS}, {@link #VALUES},
* or {@link #ENTRIES}.
*/
final int type;
/** The number of modifications to the backing Map that we know about. */
int knownMod = modCount;
/** The number of elements remaining to be returned by next(). */
int count = size;
/** Location in the table. */
int loc = table.length;
/**
* Construct a new Iterator with the supplied type.
* @param type {@link #KEYS}, {@link #VALUES}, or {@link #ENTRIES}
*/
IdentityIterator(int type)
{
this.type = type;
}
/**
* Returns true if the Iterator has more elements.
* @return true if there are more elements
* @throws ConcurrentModificationException if the Map was modified
*/
public boolean hasNext()
{
if (knownMod != modCount)
throw new ConcurrentModificationException();
return count > 0;
}
/**
* Returns the next element in the Iterator's sequential view.
* @return the next element
* @throws ConcurrentModificationException if the Map was modified
* @throws NoSuchElementException if there is none
*/
public Object next()
{
if (knownMod != modCount)
throw new ConcurrentModificationException();
if (count == 0)
throw new NoSuchElementException();
count--;
Object key;
do
{
loc -= 2;
key = table[loc];
}
while (key == emptyslot || key == tombstone);
return type == KEYS ? key : (type == VALUES ? table[loc + 1]
: new IdentityEntry(loc));
}
/**
* Removes from the backing Map the last element which was fetched
* with the <pre>next()</pre> method.
* @throws ConcurrentModificationException if the Map was modified
* @throws IllegalStateException if called when there is no last element
*/
public void remove()
{
if (knownMod != modCount)
throw new ConcurrentModificationException();
if (loc == table.length || table[loc] == tombstone)
throw new IllegalStateException();
modCount++;
size--;
table[loc] = tombstone;
table[loc + 1] = tombstone;
knownMod++;
}
} // class IdentityIterator
/**
* This class provides Map.Entry objects for IdentityHashMaps. The entry
* is fail-fast, and will throw a ConcurrentModificationException if
* the underlying map is modified, or if remove is called on the iterator
* that generated this object. It is identity based, so it violates
* the general contract of Map.Entry, and is probably unsuitable for
* comparison to normal maps; but it works among other IdentityHashMaps.
*
* @author Eric Blake <ebb9@email.byu.edu>
*/
private final class IdentityEntry implements Map.Entry
{
/** The location of this entry. */
final int loc;
/** The number of modifications to the backing Map that we know about. */
final int knownMod = modCount;
/**
* Constructs the Entry.
*
* @param loc the location of this entry in table
*/
IdentityEntry(int loc)
{
this.loc = loc;
}
/**
* Compares the specified object with this entry, using identity
* semantics. Note that this can lead to undefined results with
* Entry objects created by normal maps.
*
* @param o the object to compare
* @return true if it is equal
* @throws ConcurrentModificationException if the entry was invalidated
* by modifying the Map or calling Iterator.remove()
*/
public boolean equals(Object o)
{
if (knownMod != modCount || table[loc] == tombstone)
throw new ConcurrentModificationException();
if (! (o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry) o;
return table[loc] == e.getKey() && table[loc + 1] == e.getValue();
}
/**
* Returns the key of this entry.
*
* @return the key
* @throws ConcurrentModificationException if the entry was invalidated
* by modifying the Map or calling Iterator.remove()
*/
public Object getKey()
{
if (knownMod != modCount || table[loc] == tombstone)
throw new ConcurrentModificationException();
return table[loc];
}
/**
* Returns the value of this entry.
*
* @return the value
* @throws ConcurrentModificationException if the entry was invalidated
* by modifying the Map or calling Iterator.remove()
*/
public Object getValue()
{
if (knownMod != modCount || table[loc] == tombstone)
throw new ConcurrentModificationException();
return table[loc + 1];
}
/**
* Returns the hashcode of the entry, using identity semantics.
* Note that this can lead to undefined results with Entry objects
* created by normal maps.
*
* @return the hash code
* @throws ConcurrentModificationException if the entry was invalidated
* by modifying the Map or calling Iterator.remove()
*/
public int hashCode()
{
if (knownMod != modCount || table[loc] == tombstone)
throw new ConcurrentModificationException();
return (System.identityHashCode(table[loc])
^ System.identityHashCode(table[loc + 1]));
}
/**
* Replaces the value of this mapping, and returns the old value.
*
* @param value the new value
* @return the old value
* @throws ConcurrentModificationException if the entry was invalidated
* by modifying the Map or calling Iterator.remove()
*/
public Object setValue(Object value)
{
if (knownMod != modCount || table[loc] == tombstone)
throw new ConcurrentModificationException();
Object r = table[loc + 1];
table[loc + 1] = value;
return r;
}
/**
* This provides a string representation of the entry. It is of the form
* "key=value", where string concatenation is used on key and value.
*
* @return the string representation
* @throws ConcurrentModificationException if the entry was invalidated
* by modifying the Map or calling Iterator.remove()
*/
public final String toString()
{
if (knownMod != modCount || table[loc] == tombstone)
throw new ConcurrentModificationException();
return table[loc] + "=" + table[loc + 1];
}
} // class IdentityEntry
/**
* Reads the object from a serial stream.
*
* @param s the stream to read from
* @throws ClassNotFoundException if the underlying stream fails
* @throws IOException if the underlying stream fails
* @serialData expects the size (int), followed by that many key (Object)
* and value (Object) pairs, with the pairs in no particular
* order
*/
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
int num = s.readInt();
table = new Object[2 * Math.max(num * 2, DEFAULT_CAPACITY)];
// Read key/value pairs.
while (--num >= 0)
put(s.readObject(), s.readObject());
}
/**
* Writes the object to a serial stream.
*
* @param s the stream to write to
* @throws IOException if the underlying stream fails
* @serialData outputs the size (int), followed by that many key (Object)
* and value (Object) pairs, with the pairs in no particular
* order
*/
private void writeObject(ObjectOutputStream s)
throws IOException
{
s.defaultWriteObject();
s.writeInt(size);
for (int i = table.length - 2; i >= 0; i -= 2)
{
Object key = table[i];
if (key != tombstone && key != emptyslot)
{
s.writeObject(key);
s.writeObject(table[i + 1]);
}
}
}
}