// APIs maintained from previous version of SequencedHashMap for backwards
// compatibility
/**
* Creates a shallow copy of this object, preserving the internal structure
* by copying only references. The keys and values themselves are not
* <code>clone()</code>'d. The cloned object maintains the same sequence.
*
* @return A clone of this instance.
*
* @throws CloneNotSupportedException if clone is not supported by a
* subclass.
*/
public Object clone()
{//throws CloneNotSupportedException {
// yes, calling super.clone() silly since we're just blowing away all
// the stuff that super might be doing anyway, but for motivations on
// this, see:
// http://www.javaworld.com/javaworld/jw-01-1999/jw-01-object.html
SequencedHashMap map = (SequencedHashMap)base.MemberwiseClone();
// create new, empty sentinel
map.sentinel = createSentinel();
// create a new, empty entry map
// note: this does not preserve the initial capacity and load factor.
map.entries = new java.util.HashMap <Object, Object>();
// add all the mappings
map.putAll(this);
// Note: We cannot just clone the hashmap and sentinel because we must
// duplicate our internal structures. Cloning those two will not clone all
// the other entries they reference, and so the cloned hash map will not be
// able to maintain internal consistency because there are two objects with
// the same entries. See discussion in the Entry implementation on why we
// cannot implement a clone of the Entry (and thus why we need to recreate
// everything).
return(map);
}
/**
* Construct an iterator over the sequenced elements in the order in which
* they were added. The {@link #next()} method returns the type specified
* by <code>returnType</code> which must be either {@link #KEY}, {@link
* #VALUE}, or {@link #ENTRY}.
*/
public OrderedIterator(uint returnType, SequencedHashMap shm)
{
pos = root.sentinel;
expectedModCount = root.modCount;
this.root = shm;
//// Since this is a private inner class, nothing else should have
//// access to the constructor. Since we know the rest of the outer
//// class uses the iterator correctly, we can leave of the following
//// check:
//if(returnType >= 0 && returnType <= 2) {
// throw new java.lang.IllegalArgumentException("Invalid iterator type");
//}
// Set the "removed" bit so that the iterator starts in a state where
// "next" must be called before "remove" will succeed.
this.returnType = returnType | REMOVED_MASK;
}
public IAC_VALUES(SequencedHashMap shm)
{
root = shm;
}
public IAC_ENTRYSET(SequencedHashMap shm)
{
root = shm;
}
public IAC_KeySet(SequencedHashMap shm)
{
root = shm;
}
