/* IdentityHashSet.java

	Purpose:
		
	Description:
		
	History:
		Fri Sep 13 11:18:11  2002, Created by tomyeh

Copyright (C) 2002 Potix Corporation. All Rights Reserved.

{{IS_RIGHT
	This program is distributed under LGPL Version 2.1 in the hope that
	it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
package org.zkoss.util;

import java.util.Collection;
import java.util.Set;
import java.util.AbstractSet;
import java.util.IdentityHashMap;
import java.util.Iterator;

import org.zkoss.lang.Objects;

/**
 * Like java.util.InternalHashMap, it uses == and System.identityHashCode
 * for doing HashSet.
 *
 * @author tomyeh
 * @see IdentityComparator
 */
public class IdentityHashSet<T> extends AbstractSet<T>
implements Set<T>, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 20060622L;

    private transient IdentityHashMap<T, Object> _map;

    /**
     * Constructs a new, empty set; the backing <tt>IdentityHashMap</tt>
     * instance has default capacity (32).
     */
    public IdentityHashSet() {
		_map = new IdentityHashMap<T, Object>();
	}

	/**
	 * Constructs a new set containing the elements in the specified
	 * collection.
	 *
	 * @param c the collection whose elements are to be placed into this set.
	 * @throws NullPointerException if the specified collection is null.
	 */
	public IdentityHashSet(Collection<T> c) {
		_map = new IdentityHashMap<T, Object>(Math.max((c.size()*4)/3, 16));
		addAll(c);
	}

	/**
     * Constructs a new, empty set with the specified expected maximum size.
	 *
     * @param expectedMaxSize the expected maximum size of the map.
     * @throws IllegalArgumentException if <tt>expectedMaxSize</tt> is negative
	 */
	public IdentityHashSet(int expectedMaxSize) {
		_map = new IdentityHashMap<T, Object>(expectedMaxSize);
	}

	//-- Set --//
	public Iterator<T> iterator() {
		return _map.keySet().iterator();
	}
	public int size() {
		return _map.size();
	}
	public boolean isEmpty() {
		return _map.isEmpty();
	}
	public boolean contains(Object o) {
		return _map.containsKey(o);
	}
	public boolean add(T o) {
		return _map.put(o, Objects.UNKNOWN)==null;
	}
	public boolean remove(Object o) {
		return _map.remove(o)==Objects.UNKNOWN;
	}
	public void clear() {
		_map.clear();
	}

	@SuppressWarnings("unchecked")
	public Object clone() {
		try { 
			IdentityHashSet<T> newSet = (IdentityHashSet<T>)super.clone();
			newSet._map = (IdentityHashMap<T, Object>)_map.clone();
			return newSet;
		} catch (CloneNotSupportedException e) { 
			throw new InternalError();
		}
	}

	//-- Serializable --//
	private synchronized void writeObject(java.io.ObjectOutputStream s)
	throws java.io.IOException {
		// Write out any hidden serialization magic
		s.defaultWriteObject();

		// Write out size
		s.writeInt(_map.size());

		// Write out all elements in the proper order.
		for (T key: _map.keySet())
			s.writeObject(key);
	}
	@SuppressWarnings("unchecked")
	private void readObject(java.io.ObjectInputStream s)
	throws java.io.IOException, ClassNotFoundException {
		// Read in any hidden serialization magic
		s.defaultReadObject();

        // Read in size (number of Mappings)
        int size = s.readInt();

		// Read in IdentityHashMap capacity and load factor and create backing IdentityHashMap
		_map = new IdentityHashMap<T, Object>((size*4)/3);
			// Allow for 33% growth (i.e., capacity is >= 2* size()).

		// Read in all elements in the proper order.
		for (int i=0; i<size; i++) {
			Object e = s.readObject();
			_map.put((T)e, Objects.UNKNOWN);
		}
	}
}