package org.openflexo.toolbox;
import java.util.AbstractSet;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
public class ExtendedSet<E> extends AbstractSet<E> {
private transient HashMap<E, E> map;
public ExtendedSet() {
map = new HashMap<E, E>();
}
/**
* Returns an iterator over the elements in this set. The elements are returned in no particular order.
*
* @return an Iterator over the elements in this set
* @see ConcurrentModificationException
*/
@Override
public Iterator<E> iterator() {
return map.keySet().iterator();
}
/**
* Returns the number of elements in this set (its cardinality).
*
* @return the number of elements in this set (its cardinality)
*/
@Override
public int size() {
return map.size();
}
/**
* Returns <tt>true</tt> if this set contains no elements.
*
* @return <tt>true</tt> if this set contains no elements
*/
@Override
public boolean isEmpty() {
return map.isEmpty();
}
/**
* Returns <tt>true</tt> if this set contains the specified element. More formally, returns <tt>true</tt> if and only if this set
* contains an element <tt>e</tt> such that <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o
* element whose presence in this set is to be tested
* @return <tt>true</tt> if this set contains the specified element
*/
@Override
public boolean contains(Object o) {
return map.containsKey(o);
}
/**
* Adds the specified element to this set if it is not already present. More formally, adds the specified element <tt>e</tt> to this set
* if this set contains no element <tt>e2</tt> such that <tt>(e==null ? e2==null : e.equals(e2))</tt>. If this set
* already contains the element, the call leaves the set unchanged and returns <tt>false</tt>.
*
* @param e
* element to be added to this set
* @return <tt>true</tt> if this set did not already contain the specified element
*/
@Override
public boolean add(E e) {
return map.put(e, e) == null;
}
/**
* Returns the object equals to the specified element which is present in this Set.
*
* @param e
* @return
*/
public E get(E e) {
return map.get(e);
}
/**
* Removes the specified element from this set if it is present. More formally, removes an element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>, if this set contains such an element. Returns <tt>true</tt> if this
* set contained the element (or equivalently, if this set changed as a result of the call). (This set will not contain the element once
* the call returns.)
*
* @param o
* object to be removed from this set, if present
* @return <tt>true</tt> if the set contained the specified element
*/
@Override
public boolean remove(Object o) {
return map.remove(o) != null;
}
/**
* Removes all of the elements from this set. The set will be empty after this call returns.
*/
@Override
public void clear() {
map.clear();
}
/**
* Returns a shallow copy of this <tt>ExtendedSet</tt> instance: the elements themselves are not cloned.
*
* @return a shallow copy of this set
*/
@Override
public Object clone() {
try {
ExtendedSet<E> newSet = (ExtendedSet<E>) super.clone();
newSet.map = (HashMap<E, E>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
}