Author: bayard
Date: Tue Sep 15 05:56:40 2009
New Revision: 815097
URL: http://svn.apache.org/viewvc?rev=815097&view=rev
Log:
Merging from -r468106:814127 of collections_jdk5_branch - namely where this
code was generified; mostly in r738956.
Also see the following revisions:
------------------------------------------------------------------------
r751869 | mbenson | 2009-03-09 15:10:00 -0700 (Mon, 09 Mar 2009) | 1 line
return type narrowing
------------------------------------------------------------------------
Modified:
commons/proper/collections/trunk/src/java/org/apache/commons/collections/set/ListOrderedSet.java
Modified:
commons/proper/collections/trunk/src/java/org/apache/commons/collections/set/ListOrderedSet.java
URL:
http://svn.apache.org/viewvc/commons/proper/collections/trunk/src/java/org/apache/commons/collections/set/ListOrderedSet.java?rev=815097&r1=815096&r2=815097&view=diff
==============================================================================
---
commons/proper/collections/trunk/src/java/org/apache/commons/collections/set/ListOrderedSet.java
(original)
+++
commons/proper/collections/trunk/src/java/org/apache/commons/collections/set/ListOrderedSet.java
Tue Sep 15 05:56:40 2009
@@ -21,8 +21,10 @@
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.ListIterator;
import java.util.Set;
+import org.apache.commons.collections.OrderedIterator;
import org.apache.commons.collections.iterators.AbstractIteratorDecorator;
import org.apache.commons.collections.list.UnmodifiableList;
@@ -36,7 +38,7 @@
* <p>
* The ListOrderedSet also has various useful direct methods. These include
many
* from <code>List</code>, such as <code>get(int)</code>,
<code>remove(int)</code>
- * and <code>indexOf(int)</code>. An unmodifiable <code>List</code> view of
+ * and <code>indexOf(int)</code>. An unmodifiable <code>List</code> view of
* the set can be obtained via <code>asList()</code>.
* <p>
* This class cannot implement the <code>List</code> interface directly as
@@ -50,26 +52,26 @@
* @author Stephen Colebourne
* @author Henning P. Schmiedehausen
*/
-public class ListOrderedSet extends AbstractSerializableSetDecorator
implements Set {
+public class ListOrderedSet<E> extends AbstractSerializableSetDecorator<E>
implements Set<E> {
/** Serialization version */
private static final long serialVersionUID = -228664372470420141L;
/** Internal list to hold the sequence of objects */
- protected final List setOrder;
+ protected final List<E> setOrder;
/**
* Factory method to create an ordered set specifying the list and set to
use.
* <p>
* The list and set must both be empty.
- *
+ *
* @param set the set to decorate, must be empty and not null
* @param list the list to decorate, must be empty and not null
* @throws IllegalArgumentException if set or list is null
* @throws IllegalArgumentException if either the set or list is not empty
* @since Commons Collections 3.1
*/
- public static ListOrderedSet decorate(Set set, List list) {
+ public static <E> ListOrderedSet<E> decorate(Set<E> set, List<E> list) {
if (set == null) {
throw new IllegalArgumentException("Set must not be null");
}
@@ -79,19 +81,19 @@
if (set.size() > 0 || list.size() > 0) {
throw new IllegalArgumentException("Set and List must be empty");
}
- return new ListOrderedSet(set, list);
+ return new ListOrderedSet<E>(set, list);
}
/**
* Factory method to create an ordered set.
* <p>
* An <code>ArrayList</code> is used to retain order.
- *
+ *
* @param set the set to decorate, must not be null
* @throws IllegalArgumentException if set is null
*/
- public static ListOrderedSet decorate(Set set) {
- return new ListOrderedSet(set);
+ public static <E> ListOrderedSet<E> decorate(Set<E> set) {
+ return new ListOrderedSet<E>(set);
}
/**
@@ -101,53 +103,53 @@
* <p>
* NOTE: If the list contains duplicates, the duplicates are removed,
* altering the specified list.
- *
+ *
* @param list the list to decorate, must not be null
* @throws IllegalArgumentException if list is null
*/
- public static ListOrderedSet decorate(List list) {
+ public static <E> ListOrderedSet<E> decorate(List<E> list) {
if (list == null) {
throw new IllegalArgumentException("List must not be null");
}
- Set set = new HashSet(list);
+ Set<E> set = new HashSet<E>(list);
list.retainAll(set);
-
- return new ListOrderedSet(set, list);
+
+ return new ListOrderedSet<E>(set, list);
}
//-----------------------------------------------------------------------
/**
* Constructs a new empty <code>ListOrderedSet</code> using
* a <code>HashSet</code> and an <code>ArrayList</code> internally.
- *
+ *
* @since Commons Collections 3.1
*/
public ListOrderedSet() {
- super(new HashSet());
- setOrder = new ArrayList();
+ super(new HashSet<E>());
+ setOrder = new ArrayList<E>();
}
/**
* Constructor that wraps (not copies).
- *
+ *
* @param set the set to decorate, must not be null
* @throws IllegalArgumentException if set is null
*/
- protected ListOrderedSet(Set set) {
+ protected ListOrderedSet(Set<E> set) {
super(set);
- setOrder = new ArrayList(set);
+ setOrder = new ArrayList<E>(set);
}
/**
* Constructor that wraps (not copies) the Set and specifies the list to
use.
* <p>
* The set and list must both be correctly initialised to the same
elements.
- *
+ *
* @param set the set to decorate, must not be null
* @param list the list to decorate, must not be null
* @throws IllegalArgumentException if set or list is null
*/
- protected ListOrderedSet(Set set, List list) {
+ protected ListOrderedSet(Set<E> set, List<E> list) {
super(set);
if (list == null) {
throw new IllegalArgumentException("List must not be null");
@@ -158,10 +160,10 @@
//-----------------------------------------------------------------------
/**
* Gets an unmodifiable view of the order of the Set.
- *
+ *
* @return an unmodifiable list view
*/
- public List asList() {
+ public List<E> asList() {
return UnmodifiableList.decorate(setOrder);
}
@@ -171,27 +173,22 @@
setOrder.clear();
}
- public Iterator iterator() {
- return new OrderedSetIterator(setOrder.iterator(), collection);
+ public OrderedIterator<E> iterator() {
+ return new OrderedSetIterator<E>(setOrder.listIterator(), collection);
}
- public boolean add(Object object) {
- if (collection.contains(object)) {
- // re-adding doesn't change order
- return collection.add(object);
- } else {
- // first add, so add to both set and list
- boolean result = collection.add(object);
+ public boolean add(E object) {
+ if (collection.add(object)) {
setOrder.add(object);
- return result;
+ return true;
}
+ return false;
}
- public boolean addAll(Collection coll) {
+ public boolean addAll(Collection<? extends E> coll) {
boolean result = false;
- for (Iterator it = coll.iterator(); it.hasNext();) {
- Object object = it.next();
- result = result | add(object);
+ for (E e : coll) {
+ result |= add(e);
}
return result;
}
@@ -202,25 +199,24 @@
return result;
}
- public boolean removeAll(Collection coll) {
+ public boolean removeAll(Collection<?> coll) {
boolean result = false;
- for (Iterator it = coll.iterator(); it.hasNext();) {
- Object object = it.next();
- result = result | remove(object);
+ for (Iterator<?> it = coll.iterator(); it.hasNext();) {
+ result |= remove(it.next());
}
return result;
}
- public boolean retainAll(Collection coll) {
+ public boolean retainAll(Collection<?> coll) {
boolean result = collection.retainAll(coll);
if (result == false) {
return false;
- } else if (collection.size() == 0) {
+ }
+ if (collection.size() == 0) {
setOrder.clear();
} else {
- for (Iterator it = setOrder.iterator(); it.hasNext();) {
- Object object = it.next();
- if (collection.contains(object) == false) {
+ for (Iterator<E> it = setOrder.iterator(); it.hasNext();) {
+ if (!collection.contains(it.next())) {
it.remove();
}
}
@@ -232,12 +228,12 @@
return setOrder.toArray();
}
- public Object[] toArray(Object a[]) {
+ public <T> T[] toArray(T a[]) {
return setOrder.toArray(a);
}
//-----------------------------------------------------------------------
- public Object get(int index) {
+ public E get(int index) {
return setOrder.get(index);
}
@@ -245,23 +241,22 @@
return setOrder.indexOf(object);
}
- public void add(int index, Object object) {
- if (contains(object) == false) {
+ public void add(int index, E object) {
+ if (!contains(object)) {
collection.add(object);
setOrder.add(index, object);
}
}
- public boolean addAll(int index, Collection coll) {
+ public boolean addAll(int index, Collection<? extends E> coll) {
boolean changed = false;
- for (Iterator it = coll.iterator(); it.hasNext();) {
- Object object = it.next();
- if (contains(object) == false) {
- collection.add(object);
- setOrder.add(index, object);
- index++;
- changed = true;
+ for (E e : coll) {
+ if (contains(e)) {
+ continue;
}
+ collection.add(e);
+ setOrder.add(index++, e);
+ changed = true;
}
return changed;
}
@@ -273,9 +268,9 @@
}
/**
- * Uses the underlying List's toString so that order is achieved.
- * This means that the decorated Set's toString is not used, so
- * any custom toStrings will be ignored.
+ * Uses the underlying List's toString so that order is achieved.
+ * This means that the decorated Set's toString is not used, so
+ * any custom toStrings will be ignored.
*/
// Fortunately List.toString and Set.toString look the same
public String toString() {
@@ -286,19 +281,20 @@
/**
* Internal iterator handle remove.
*/
- static class OrderedSetIterator extends AbstractIteratorDecorator {
-
+ static class OrderedSetIterator<E> extends AbstractIteratorDecorator<E>
implements OrderedIterator<E> {
+
/** Object we iterate on */
- protected final Collection set;
+ protected final Collection<E> set;
+
/** Last object retrieved */
- protected Object last;
+ protected E last;
- private OrderedSetIterator(Iterator iterator, Collection set) {
+ private OrderedSetIterator(ListIterator<E> iterator, Collection<E>
set) {
super(iterator);
this.set = set;
}
- public Object next() {
+ public E next() {
last = iterator.next();
return last;
}
@@ -308,6 +304,15 @@
iterator.remove();
last = null;
}
+
+ public boolean hasPrevious() {
+ return ((ListIterator<E>) iterator).hasPrevious();
+ }
+
+ public E previous() {
+ last = ((ListIterator<E>) iterator).previous();
+ return last;
+ }
}
}
