http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/keyvalue/TiedMapEntry.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/keyvalue/TiedMapEntry.java b/src/java/org/apache/commons/collections/keyvalue/TiedMapEntry.java index a793824..46d2083 100644 --- a/src/java/org/apache/commons/collections/keyvalue/TiedMapEntry.java +++ b/src/java/org/apache/commons/collections/keyvalue/TiedMapEntry.java @@ -32,15 +32,16 @@ import org.apache.commons.collections.KeyValue; * * @author Stephen Colebourne */ -public class TiedMapEntry implements Map.Entry, KeyValue, Serializable { +public class TiedMapEntry<K, V> implements Map.Entry<K, V>, KeyValue<K, V>, Serializable { /** Serialization version */ private static final long serialVersionUID = -8453869361373831205L; /** The map underlying the entry/iterator */ - private final Map map; + private final Map<K, V> map; + /** The key */ - private final Object key; + private final K key; /** * Constructs a new entry with the given Map and key. @@ -48,7 +49,7 @@ public class TiedMapEntry implements Map.Entry, KeyValue, Serializable { * @param map the map * @param key the key */ - public TiedMapEntry(Map map, Object key) { + public TiedMapEntry(Map<K, V> map, K key) { super(); this.map = map; this.key = key; @@ -61,7 +62,7 @@ public class TiedMapEntry implements Map.Entry, KeyValue, Serializable { * * @return the key */ - public Object getKey() { + public K getKey() { return key; } @@ -70,7 +71,7 @@ public class TiedMapEntry implements Map.Entry, KeyValue, Serializable { * * @return the value */ - public Object getValue() { + public V getValue() { return map.get(key); } @@ -81,7 +82,7 @@ public class TiedMapEntry implements Map.Entry, KeyValue, Serializable { * @return the old value * @throws IllegalArgumentException if the value is set to this map entry */ - public Object setValue(Object value) { + public V setValue(V value) { if (value == this) { throw new IllegalArgumentException("Cannot set value to this map entry"); } @@ -96,6 +97,7 @@ public class TiedMapEntry implements Map.Entry, KeyValue, Serializable { * @param obj the object to compare to * @return true if equal key and value */ + @SuppressWarnings("unchecked") public boolean equals(Object obj) { if (obj == this) { return true;
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/keyvalue/UnmodifiableMapEntry.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/keyvalue/UnmodifiableMapEntry.java b/src/java/org/apache/commons/collections/keyvalue/UnmodifiableMapEntry.java index 047967e..c316bbc 100644 --- a/src/java/org/apache/commons/collections/keyvalue/UnmodifiableMapEntry.java +++ b/src/java/org/apache/commons/collections/keyvalue/UnmodifiableMapEntry.java @@ -30,7 +30,7 @@ import org.apache.commons.collections.Unmodifiable; * * @author Stephen Colebourne */ -public final class UnmodifiableMapEntry extends AbstractMapEntry implements Unmodifiable { +public final class UnmodifiableMapEntry<K, V> extends AbstractMapEntry<K, V> implements Unmodifiable { /** * Constructs a new entry with the specified key and given value. @@ -38,7 +38,7 @@ public final class UnmodifiableMapEntry extends AbstractMapEntry implements Unmo * @param key the key for the entry, may be null * @param value the value for the entry, may be null */ - public UnmodifiableMapEntry(final Object key, final Object value) { + public UnmodifiableMapEntry(final K key, final V value) { super(key, value); } @@ -48,7 +48,7 @@ public final class UnmodifiableMapEntry extends AbstractMapEntry implements Unmo * @param pair the pair to copy, must not be null * @throws NullPointerException if the entry is null */ - public UnmodifiableMapEntry(final KeyValue pair) { + public UnmodifiableMapEntry(final KeyValue<K, V> pair) { super(pair.getKey(), pair.getValue()); } @@ -58,7 +58,7 @@ public final class UnmodifiableMapEntry extends AbstractMapEntry implements Unmo * @param entry the entry to copy, must not be null * @throws NullPointerException if the entry is null */ - public UnmodifiableMapEntry(final Map.Entry entry) { + public UnmodifiableMapEntry(final Map.Entry<K, V> entry) { super(entry.getKey(), entry.getValue()); } @@ -69,7 +69,7 @@ public final class UnmodifiableMapEntry extends AbstractMapEntry implements Unmo * @return the previous value * @throws UnsupportedOperationException always */ - public Object setValue(Object value) { + public V setValue(V value) { throw new UnsupportedOperationException("setValue() is not supported"); } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/AbstractLinkedList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/AbstractLinkedList.java b/src/java/org/apache/commons/collections/list/AbstractLinkedList.java index 04c7357..738871e 100644 --- a/src/java/org/apache/commons/collections/list/AbstractLinkedList.java +++ b/src/java/org/apache/commons/collections/list/AbstractLinkedList.java @@ -5,9 +5,9 @@ * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -37,7 +37,7 @@ import org.apache.commons.collections.OrderedIterator; * Overridable methods are provided to change the storage node and to change how * nodes are added to and removed. Hopefully, all you need for unusual subclasses * is here. - * + * * @since Commons Collections 3.0 * @version $Revision$ $Date$ * @@ -45,7 +45,7 @@ import org.apache.commons.collections.OrderedIterator; * @author Phil Steitz * @author Stephen Colebourne */ -public abstract class AbstractLinkedList implements List { +public abstract class AbstractLinkedList<E> implements List<E> { /* * Implementation notes: @@ -63,9 +63,11 @@ public abstract class AbstractLinkedList implements List { * hold a value. The value of <code>next</code> is the first item in the * list. The value of of <code>previous</code> is the last item in the list. */ - protected transient Node header; + protected transient Node<E> header; + /** The size of the list */ protected transient int size; + /** Modification count for iterators */ protected transient int modCount; @@ -81,10 +83,10 @@ public abstract class AbstractLinkedList implements List { /** * Constructs a list copying data from the specified collection. - * + * * @param coll the collection to copy */ - protected AbstractLinkedList(Collection coll) { + protected AbstractLinkedList(Collection<? extends E> coll) { super(); init(); addAll(coll); @@ -109,28 +111,28 @@ public abstract class AbstractLinkedList implements List { return (size() == 0); } - public Object get(int index) { - Node node = getNode(index, false); + public E get(int index) { + Node<E> node = getNode(index, false); return node.getValue(); } //----------------------------------------------------------------------- - public Iterator iterator() { + public Iterator<E> iterator() { return listIterator(); } - public ListIterator listIterator() { - return new LinkedListIterator(this, 0); + public ListIterator<E> listIterator() { + return new LinkedListIterator<E>(this, 0); } - public ListIterator listIterator(int fromIndex) { - return new LinkedListIterator(this, fromIndex); + public ListIterator<E> listIterator(int fromIndex) { + return new LinkedListIterator<E>(this, fromIndex); } //----------------------------------------------------------------------- public int indexOf(Object value) { int i = 0; - for (Node node = header.next; node != header; node = node.next) { + for (Node<E> node = header.next; node != header; node = node.next) { if (isEqualValue(node.getValue(), value)) { return i; } @@ -141,7 +143,7 @@ public abstract class AbstractLinkedList implements List { public int lastIndexOf(Object value) { int i = size - 1; - for (Node node = header.previous; node != header; node = node.previous) { + for (Node<E> node = header.previous; node != header; node = node.previous) { if (isEqualValue(node.getValue(), value)) { return i; } @@ -154,31 +156,31 @@ public abstract class AbstractLinkedList implements List { return indexOf(value) != -1; } - public boolean containsAll(Collection coll) { - Iterator it = coll.iterator(); - while (it.hasNext()) { - if (contains(it.next()) == false) { + public boolean containsAll(Collection<?> coll) { + for (Object o : coll) { + if (!contains(o)) { return false; } } return true; } - + //----------------------------------------------------------------------- public Object[] toArray() { return toArray(new Object[size]); } - public Object[] toArray(Object[] array) { + @SuppressWarnings("unchecked") + public <T> T[] toArray(T[] array) { // Extend the array if needed if (array.length < size) { Class componentType = array.getClass().getComponentType(); - array = (Object[]) Array.newInstance(componentType, size); + array = (T[]) Array.newInstance(componentType, size); } // Copy the values into the array int i = 0; - for (Node node = header.next; node != header; node = node.next, i++) { - array[i] = node.getValue(); + for (Node<E> node = header.next; node != header; node = node.next, i++) { + array[i] = (T) node.getValue(); } // Set the value after the last value to null if (array.length > size) { @@ -189,49 +191,48 @@ public abstract class AbstractLinkedList implements List { /** * Gets a sublist of the main list. - * + * * @param fromIndexInclusive the index to start from * @param toIndexExclusive the index to end at * @return the new sublist */ - public List subList(int fromIndexInclusive, int toIndexExclusive) { - return new LinkedSubList(this, fromIndexInclusive, toIndexExclusive); + public List<E> subList(int fromIndexInclusive, int toIndexExclusive) { + return new LinkedSubList<E>(this, fromIndexInclusive, toIndexExclusive); } - + //----------------------------------------------------------------------- - public boolean add(Object value) { + public boolean add(E value) { addLast(value); return true; } - - public void add(int index, Object value) { - Node node = getNode(index, true); + + public void add(int index, E value) { + Node<E> node = getNode(index, true); addNodeBefore(node, value); } - - public boolean addAll(Collection coll) { + + public boolean addAll(Collection<? extends E> coll) { return addAll(size, coll); } - public boolean addAll(int index, Collection coll) { - Node node = getNode(index, true); - for (Iterator itr = coll.iterator(); itr.hasNext();) { - Object value = itr.next(); - addNodeBefore(node, value); + public boolean addAll(int index, Collection<? extends E> coll) { + Node<E> node = getNode(index, true); + for (E e : coll) { + addNodeBefore(node, e); } return true; } //----------------------------------------------------------------------- - public Object remove(int index) { - Node node = getNode(index, false); - Object oldValue = node.getValue(); + public E remove(int index) { + Node<E> node = getNode(index, false); + E oldValue = node.getValue(); removeNode(node); return oldValue; } public boolean remove(Object value) { - for (Node node = header.next; node != header; node = node.next) { + for (Node<E> node = header.next; node != header; node = node.next) { if (isEqualValue(node.getValue(), value)) { removeNode(node); return true; @@ -240,9 +241,9 @@ public abstract class AbstractLinkedList implements List { return false; } - public boolean removeAll(Collection coll) { + public boolean removeAll(Collection<?> coll) { boolean modified = false; - Iterator it = iterator(); + Iterator<E> it = iterator(); while (it.hasNext()) { if (coll.contains(it.next())) { it.remove(); @@ -253,9 +254,9 @@ public abstract class AbstractLinkedList implements List { } //----------------------------------------------------------------------- - public boolean retainAll(Collection coll) { + public boolean retainAll(Collection<?> coll) { boolean modified = false; - Iterator it = iterator(); + Iterator<E> it = iterator(); while (it.hasNext()) { if (coll.contains(it.next()) == false) { it.remove(); @@ -265,9 +266,9 @@ public abstract class AbstractLinkedList implements List { return modified; } - public Object set(int index, Object value) { - Node node = getNode(index, false); - Object oldValue = node.getValue(); + public E set(int index, E value) { + Node<E> node = getNode(index, false); + E oldValue = node.getValue(); updateNode(node, value); return oldValue; } @@ -275,55 +276,56 @@ public abstract class AbstractLinkedList implements List { public void clear() { removeAllNodes(); } - + //----------------------------------------------------------------------- - public Object getFirst() { - Node node = header.next; + public E getFirst() { + Node<E> node = header.next; if (node == header) { throw new NoSuchElementException(); } return node.getValue(); } - public Object getLast() { - Node node = header.previous; + public E getLast() { + Node<E> node = header.previous; if (node == header) { throw new NoSuchElementException(); } return node.getValue(); } - public boolean addFirst(Object o) { + public boolean addFirst(E o) { addNodeAfter(header, o); return true; } - public boolean addLast(Object o) { + public boolean addLast(E o) { addNodeBefore(header, o); return true; } - public Object removeFirst() { - Node node = header.next; + public E removeFirst() { + Node<E> node = header.next; if (node == header) { throw new NoSuchElementException(); } - Object oldValue = node.getValue(); + E oldValue = node.getValue(); removeNode(node); return oldValue; } - public Object removeLast() { - Node node = header.previous; + public E removeLast() { + Node<E> node = header.previous; if (node == header) { throw new NoSuchElementException(); } - Object oldValue = node.getValue(); + E oldValue = node.getValue(); removeNode(node); return oldValue; } //----------------------------------------------------------------------- + @SuppressWarnings("unchecked") public boolean equals(Object obj) { if (obj == this) { return true; @@ -348,10 +350,8 @@ public abstract class AbstractLinkedList implements List { public int hashCode() { int hashCode = 1; - Iterator it = iterator(); - while (it.hasNext()) { - Object obj = it.next(); - hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode()); + for (E e : this) { + hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode()); } return hashCode; } @@ -363,7 +363,7 @@ public abstract class AbstractLinkedList implements List { StringBuffer buf = new StringBuffer(16 * size()); buf.append("["); - Iterator it = iterator(); + Iterator<E> it = iterator(); boolean hasNext = it.hasNext(); while (hasNext) { Object value = it.next(); @@ -382,7 +382,7 @@ public abstract class AbstractLinkedList implements List { * Compares two values for equals. * This implementation uses the equals method. * Subclasses can override this to match differently. - * + * * @param value1 the first value to compare, may be null * @param value2 the second value to compare, may be null * @return true if equal @@ -390,16 +390,16 @@ public abstract class AbstractLinkedList implements List { protected boolean isEqualValue(Object value1, Object value2) { return (value1 == value2 || (value1 == null ? false : value1.equals(value2))); } - + /** * Updates the node with a new value. * This implementation sets the value on the node. * Subclasses can override this to record the change. - * + * * @param node node to update * @param value new value of the node */ - protected void updateNode(Node node, Object value) { + protected void updateNode(Node<E> node, E value) { node.setValue(value); } @@ -407,26 +407,26 @@ public abstract class AbstractLinkedList implements List { * Creates a new node with previous, next and element all set to null. * This implementation creates a new empty Node. * Subclasses can override this to create a different class. - * + * * @return newly created node */ - protected Node createHeaderNode() { - return new Node(); + protected Node<E> createHeaderNode() { + return new Node<E>(); } /** * Creates a new node with the specified properties. * This implementation creates a new Node with data. * Subclasses can override this to create a different class. - * + * * @param value value of the new node */ - protected Node createNode(Object value) { - return new Node(value); + protected Node<E> createNode(E value) { + return new Node<E>(value); } /** - * Creates a new node with the specified object as its + * Creates a new node with the specified object as its * <code>value</code> and inserts it before <code>node</code>. * <p> * This implementation uses {@link #createNode(Object)} and @@ -436,24 +436,24 @@ public abstract class AbstractLinkedList implements List { * @param value value of the newly added node * @throws NullPointerException if <code>node</code> is null */ - protected void addNodeBefore(Node node, Object value) { - Node newNode = createNode(value); + protected void addNodeBefore(Node<E> node, E value) { + Node<E> newNode = createNode(value); addNode(newNode, node); } /** - * Creates a new node with the specified object as its + * Creates a new node with the specified object as its * <code>value</code> and inserts it after <code>node</code>. * <p> * This implementation uses {@link #createNode(Object)} and * {@link #addNode(AbstractLinkedList.Node,AbstractLinkedList.Node)}. - * + * * @param node node to insert after * @param value value of the newly added node * @throws NullPointerException if <code>node</code> is null */ - protected void addNodeAfter(Node node, Object value) { - Node newNode = createNode(value); + protected void addNodeAfter(Node<E> node, E value) { + Node<E> newNode = createNode(value); addNode(newNode, node.next); } @@ -464,7 +464,7 @@ public abstract class AbstractLinkedList implements List { * @param insertBeforeNode node to insert before * @throws NullPointerException if either node is null */ - protected void addNode(Node nodeToInsert, Node insertBeforeNode) { + protected void addNode(Node<E> nodeToInsert, Node<E> insertBeforeNode) { nodeToInsert.next = insertBeforeNode; nodeToInsert.previous = insertBeforeNode.previous; insertBeforeNode.previous.next = nodeToInsert; @@ -479,7 +479,7 @@ public abstract class AbstractLinkedList implements List { * @param node the node to remove * @throws NullPointerException if <code>node</code> is null */ - protected void removeNode(Node node) { + protected void removeNode(Node<E> node) { node.previous.next = node.next; node.next.previous = node.previous; size--; @@ -498,7 +498,7 @@ public abstract class AbstractLinkedList implements List { /** * Gets the node at a particular index. - * + * * @param index the index, starting from 0 * @param endMarkerAllowed whether or not the end marker can be returned if * startIndex is set to the list's size @@ -506,7 +506,7 @@ public abstract class AbstractLinkedList implements List { * the size of the list and endMakerAllowed is false; or greater than the * size of the list */ - protected Node getNode(int index, boolean endMarkerAllowed) throws IndexOutOfBoundsException { + protected Node<E> getNode(int index, boolean endMarkerAllowed) throws IndexOutOfBoundsException { // Check the index is within the bounds if (index < 0) { throw new IndexOutOfBoundsException("Couldn't get the node: " + @@ -522,7 +522,7 @@ public abstract class AbstractLinkedList implements List { "list (" + size + ")."); } // Search the list and get the node - Node node; + Node<E> node; if (index < (size / 2)) { // Search forwards node = header.next; @@ -542,21 +542,21 @@ public abstract class AbstractLinkedList implements List { //----------------------------------------------------------------------- /** * Creates an iterator for the sublist. - * + * * @param subList the sublist to get an iterator for */ - protected Iterator createSubListIterator(LinkedSubList subList) { + protected Iterator<E> createSubListIterator(LinkedSubList<E> subList) { return createSubListListIterator(subList, 0); } /** * Creates a list iterator for the sublist. - * + * * @param subList the sublist to get an iterator for * @param fromIndex the index to start from, relative to the sublist */ - protected ListIterator createSubListListIterator(LinkedSubList subList, int fromIndex) { - return new LinkedSubListIterator(subList, fromIndex); + protected ListIterator<E> createSubListListIterator(LinkedSubList<E> subList, int fromIndex) { + return new LinkedSubListIterator<E>(subList, fromIndex); } //----------------------------------------------------------------------- @@ -569,7 +569,7 @@ public abstract class AbstractLinkedList implements List { protected void doWriteObject(ObjectOutputStream outputStream) throws IOException { // Write the size so we know how many nodes to read back outputStream.writeInt(size()); - for (Iterator itr = iterator(); itr.hasNext();) { + for (Iterator<E> itr = iterator(); itr.hasNext();) { outputStream.writeObject(itr.next()); } } @@ -580,11 +580,12 @@ public abstract class AbstractLinkedList implements List { * The first serializable subclass must call this method from * <code>readObject</code>. */ + @SuppressWarnings("unchecked") protected void doReadObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException { init(); int size = inputStream.readInt(); for (int i = 0; i < size; i++) { - add(inputStream.readObject()); + add((E) inputStream.readObject()); } } @@ -595,14 +596,14 @@ public abstract class AbstractLinkedList implements List { * From Commons Collections 3.1, all access to the <code>value</code> property * is via the methods on this class. */ - protected static class Node { + protected static class Node<E> { /** A pointer to the node before this node */ - protected Node previous; + protected Node<E> previous; /** A pointer to the node after this node */ - protected Node next; + protected Node<E> next; /** The object contained within this node */ - protected Object value; + protected E value; /** * Constructs a new header node. @@ -615,85 +616,85 @@ public abstract class AbstractLinkedList implements List { /** * Constructs a new node. - * + * * @param value the value to store */ - protected Node(Object value) { + protected Node(E value) { super(); this.value = value; } - + /** * Constructs a new node. - * + * * @param previous the previous node in the list * @param next the next node in the list * @param value the value to store */ - protected Node(Node previous, Node next, Object value) { + protected Node(Node<E> previous, Node<E> next, E value) { super(); this.previous = previous; this.next = next; this.value = value; } - + /** * Gets the value of the node. - * + * * @return the value * @since Commons Collections 3.1 */ - protected Object getValue() { + protected E getValue() { return value; } - + /** * Sets the value of the node. - * + * * @param value the value * @since Commons Collections 3.1 */ - protected void setValue(Object value) { + protected void setValue(E value) { this.value = value; } - + /** * Gets the previous node. - * + * * @return the previous node * @since Commons Collections 3.1 */ - protected Node getPreviousNode() { + protected Node<E> getPreviousNode() { return previous; } - + /** * Sets the previous node. - * + * * @param previous the previous node * @since Commons Collections 3.1 */ - protected void setPreviousNode(Node previous) { + protected void setPreviousNode(Node<E> previous) { this.previous = previous; } - + /** * Gets the next node. - * + * * @return the next node * @since Commons Collections 3.1 */ - protected Node getNextNode() { + protected Node<E> getNextNode() { return next; } - + /** * Sets the next node. - * + * * @param next the next node * @since Commons Collections 3.1 */ - protected void setNextNode(Node next) { + protected void setNextNode(Node<E> next) { this.next = next; } } @@ -702,16 +703,16 @@ public abstract class AbstractLinkedList implements List { /** * A list iterator over the linked list. */ - protected static class LinkedListIterator implements ListIterator, OrderedIterator { - + protected static class LinkedListIterator<E> implements ListIterator<E>, OrderedIterator<E> { + /** The parent list */ - protected final AbstractLinkedList parent; + protected final AbstractLinkedList<E> parent; /** * The node that will be returned by {@link #next()}. If this is equal * to {@link AbstractLinkedList#header} then there are no more values to return. */ - protected Node next; + protected Node<E> next; /** * The index of {@link #next}. @@ -726,7 +727,7 @@ public abstract class AbstractLinkedList implements List { * Should be accessed through {@link #getLastNodeReturned()} to enforce * this behaviour. */ - protected Node current; + protected Node<E> current; /** * The modification count that the list is expected to have. If the list @@ -738,11 +739,11 @@ public abstract class AbstractLinkedList implements List { /** * Create a ListIterator for a list. - * + * * @param parent the parent list * @param fromIndex the index to start at */ - protected LinkedListIterator(AbstractLinkedList parent, int fromIndex) throws IndexOutOfBoundsException { + protected LinkedListIterator(AbstractLinkedList<E> parent, int fromIndex) throws IndexOutOfBoundsException { super(); this.parent = parent; this.expectedModCount = parent.modCount; @@ -753,7 +754,7 @@ public abstract class AbstractLinkedList implements List { /** * Checks the modification count of the list is the value that this * object expects. - * + * * @throws ConcurrentModificationException If the list's modification * count isn't the value that was expected. */ @@ -765,12 +766,12 @@ public abstract class AbstractLinkedList implements List { /** * Gets the last node returned. - * + * * @throws IllegalStateException If {@link #next()} or * {@link #previous()} haven't been called, or if the node has been removed * with {@link #remove()} or a new node added with {@link #add(Object)}. */ - protected Node getLastNodeReturned() throws IllegalStateException { + protected Node<E> getLastNodeReturned() throws IllegalStateException { if (current == null) { throw new IllegalStateException(); } @@ -781,12 +782,12 @@ public abstract class AbstractLinkedList implements List { return next != parent.header; } - public Object next() { + public E next() { checkModCount(); if (!hasNext()) { throw new NoSuchElementException("No element at index " + nextIndex + "."); } - Object value = next.getValue(); + E value = next.getValue(); current = next; next = next.next; nextIndex++; @@ -797,13 +798,13 @@ public abstract class AbstractLinkedList implements List { return next.previous != parent.header; } - public Object previous() { + public E previous() { checkModCount(); if (!hasPrevious()) { throw new NoSuchElementException("Already at start of list."); } next = next.previous; - Object value = next.getValue(); + E value = next.getValue(); current = next; nextIndex--; return value; @@ -833,12 +834,12 @@ public abstract class AbstractLinkedList implements List { expectedModCount++; } - public void set(Object obj) { + public void set(E obj) { checkModCount(); getLastNodeReturned().setValue(obj); } - public void add(Object obj) { + public void add(E obj) { checkModCount(); parent.addNodeBefore(next, obj); current = null; @@ -852,12 +853,12 @@ public abstract class AbstractLinkedList implements List { /** * A list iterator over the linked sub list. */ - protected static class LinkedSubListIterator extends LinkedListIterator { - + protected static class LinkedSubListIterator<E> extends LinkedListIterator<E> { + /** The parent list */ - protected final LinkedSubList sub; - - protected LinkedSubListIterator(LinkedSubList sub, int startIndex) { + protected final LinkedSubList<E> sub; + + protected LinkedSubListIterator(LinkedSubList<E> sub, int startIndex) { super(sub.parent, startIndex + sub.offset); this.sub = sub; } @@ -874,26 +875,26 @@ public abstract class AbstractLinkedList implements List { return (super.nextIndex() - sub.offset); } - public void add(Object obj) { + public void add(E obj) { super.add(obj); sub.expectedModCount = parent.modCount; sub.size++; } - + public void remove() { super.remove(); sub.expectedModCount = parent.modCount; sub.size--; } } - + //----------------------------------------------------------------------- /** * The sublist implementation for AbstractLinkedList. */ - protected static class LinkedSubList extends AbstractList { + protected static class LinkedSubList<E> extends AbstractList<E> { /** The main list */ - AbstractLinkedList parent; + AbstractLinkedList<E> parent; /** Offset from the main list */ int offset; /** Sublist size */ @@ -901,7 +902,7 @@ public abstract class AbstractLinkedList implements List { /** Sublist modCount */ int expectedModCount; - protected LinkedSubList(AbstractLinkedList parent, int fromIndex, int toIndex) { + protected LinkedSubList(AbstractLinkedList<E> parent, int fromIndex, int toIndex) { if (fromIndex < 0) { throw new IndexOutOfBoundsException("fromIndex = " + fromIndex); } @@ -922,13 +923,13 @@ public abstract class AbstractLinkedList implements List { return size; } - public Object get(int index) { + public E get(int index) { rangeCheck(index, size); checkModCount(); return parent.get(index + offset); } - public void add(int index, Object obj) { + public void add(int index, E obj) { rangeCheck(index, size + 1); checkModCount(); parent.add(index + offset, obj); @@ -937,21 +938,21 @@ public abstract class AbstractLinkedList implements List { LinkedSubList.this.modCount++; } - public Object remove(int index) { + public E remove(int index) { rangeCheck(index, size); checkModCount(); - Object result = parent.remove(index + offset); + E result = parent.remove(index + offset); expectedModCount = parent.modCount; size--; LinkedSubList.this.modCount++; return result; } - public boolean addAll(Collection coll) { + public boolean addAll(Collection<? extends E> coll) { return addAll(size, coll); } - public boolean addAll(int index, Collection coll) { + public boolean addAll(int index, Collection<? extends E> coll) { rangeCheck(index, size + 1); int cSize = coll.size(); if (cSize == 0) { @@ -966,7 +967,7 @@ public abstract class AbstractLinkedList implements List { return true; } - public Object set(int index, Object obj) { + public E set(int index, E obj) { rangeCheck(index, size); checkModCount(); return parent.set(index + offset, obj); @@ -974,26 +975,26 @@ public abstract class AbstractLinkedList implements List { public void clear() { checkModCount(); - Iterator it = iterator(); + Iterator<E> it = iterator(); while (it.hasNext()) { it.next(); it.remove(); } } - public Iterator iterator() { + public Iterator<E> iterator() { checkModCount(); return parent.createSubListIterator(this); } - public ListIterator listIterator(final int index) { + public ListIterator<E> listIterator(final int index) { rangeCheck(index, size + 1); checkModCount(); return parent.createSubListListIterator(this, index); } - public List subList(int fromIndexInclusive, int toIndexExclusive) { - return new LinkedSubList(parent, fromIndexInclusive + offset, toIndexExclusive + offset); + public List<E> subList(int fromIndexInclusive, int toIndexExclusive) { + return new LinkedSubList<E>(parent, fromIndexInclusive + offset, toIndexExclusive + offset); } protected void rangeCheck(int index, int beyond) { @@ -1008,5 +1009,5 @@ public abstract class AbstractLinkedList implements List { } } } - + } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/AbstractListDecorator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/AbstractListDecorator.java b/src/java/org/apache/commons/collections/list/AbstractListDecorator.java index ecd48f2..c8550d2 100644 --- a/src/java/org/apache/commons/collections/list/AbstractListDecorator.java +++ b/src/java/org/apache/commons/collections/list/AbstractListDecorator.java @@ -33,9 +33,11 @@ import org.apache.commons.collections.collection.AbstractCollectionDecorator; * * @author Stephen Colebourne */ -public abstract class AbstractListDecorator<E> - extends AbstractCollectionDecorator<E> - implements List<E> { +public abstract class AbstractListDecorator<E> extends AbstractCollectionDecorator<E> implements + List<E> { + + /** Serialization version--necessary in an abstract class? */ + private static final long serialVersionUID = 4500739654952315623L; /** * Constructor only used in deserialization, do not use otherwise. http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/AbstractSerializableListDecorator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/AbstractSerializableListDecorator.java b/src/java/org/apache/commons/collections/list/AbstractSerializableListDecorator.java index 7793581..eac1c3a 100644 --- a/src/java/org/apache/commons/collections/list/AbstractSerializableListDecorator.java +++ b/src/java/org/apache/commons/collections/list/AbstractSerializableListDecorator.java @@ -29,8 +29,8 @@ import java.util.List; * @author Stephen Colebourne * @since Commons Collections 3.1 */ -public abstract class AbstractSerializableListDecorator - extends AbstractListDecorator +public abstract class AbstractSerializableListDecorator<E> + extends AbstractListDecorator<E> implements Serializable { /** Serialization version */ @@ -39,7 +39,7 @@ public abstract class AbstractSerializableListDecorator /** * Constructor. */ - protected AbstractSerializableListDecorator(List list) { + protected AbstractSerializableListDecorator(List<E> list) { super(list); } @@ -62,9 +62,10 @@ public abstract class AbstractSerializableListDecorator * @throws IOException * @throws ClassNotFoundException */ + @SuppressWarnings("unchecked") private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); - collection = (Collection) in.readObject(); + collection = (Collection<E>) in.readObject(); } } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/CursorableLinkedList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/CursorableLinkedList.java b/src/java/org/apache/commons/collections/list/CursorableLinkedList.java index b6ce57d..022eaaa 100644 --- a/src/java/org/apache/commons/collections/list/CursorableLinkedList.java +++ b/src/java/org/apache/commons/collections/list/CursorableLinkedList.java @@ -60,13 +60,13 @@ import java.util.ListIterator; * @author Simon Kitching * @author Stephen Colebourne */ -public class CursorableLinkedList extends AbstractLinkedList implements Serializable { +public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Serializable { /** Ensure serialization compatibility */ private static final long serialVersionUID = 8836393098519411393L; /** A list of the cursor currently open on this list */ - protected transient List cursors = new ArrayList(); + protected transient List<WeakReference<Cursor<E>>> cursors; //----------------------------------------------------------------------- /** @@ -82,7 +82,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param coll the collection to copy */ - public CursorableLinkedList(Collection coll) { + public CursorableLinkedList(Collection<E> coll) { super(coll); } @@ -92,7 +92,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ */ protected void init() { super.init(); - cursors = new ArrayList(); + cursors = new ArrayList<WeakReference<Cursor<E>>>(); } //----------------------------------------------------------------------- @@ -105,7 +105,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @return a new iterator that does <b>not</b> support concurrent modification */ - public Iterator iterator() { + public Iterator<E> iterator() { return super.listIterator(0); } @@ -124,7 +124,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @return a new cursor iterator */ - public ListIterator listIterator() { + public ListIterator<E> listIterator() { return cursor(0); } @@ -144,7 +144,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * @param fromIndex the index to start from * @return a new cursor iterator */ - public ListIterator listIterator(int fromIndex) { + public ListIterator<E> listIterator(int fromIndex) { return cursor(fromIndex); } @@ -171,7 +171,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @return a new cursor iterator */ - public CursorableLinkedList.Cursor cursor() { + public CursorableLinkedList.Cursor<E> cursor() { return cursor(0); } @@ -202,8 +202,8 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index > size()). */ - public CursorableLinkedList.Cursor cursor(int fromIndex) { - Cursor cursor = new Cursor(this, fromIndex); + public CursorableLinkedList.Cursor<E> cursor(int fromIndex) { + Cursor<E> cursor = new Cursor<E>(this, fromIndex); registerCursor(cursor); return cursor; } @@ -217,7 +217,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * @param node node to update * @param value new value of the node */ - protected void updateNode(Node node, Object value) { + protected void updateNode(Node<E> node, E value) { super.updateNode(node, value); broadcastNodeChanged(node); } @@ -229,7 +229,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * @param insertBeforeNode node to insert before * @throws NullPointerException if either node is null */ - protected void addNode(Node nodeToInsert, Node insertBeforeNode) { + protected void addNode(Node<E> nodeToInsert, Node<E> insertBeforeNode) { super.addNode(nodeToInsert, insertBeforeNode); broadcastNodeInserted(nodeToInsert); } @@ -240,7 +240,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * @param node the node to remove * @throws NullPointerException if <code>node</code> is null */ - protected void removeNode(Node node) { + protected void removeNode(Node<E> node) { super.removeNode(node); broadcastNodeRemoved(node); } @@ -251,7 +251,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ protected void removeAllNodes() { if (size() > 0) { // superclass implementation would break all the iterators - Iterator it = iterator(); + Iterator<E> it = iterator(); while (it.hasNext()) { it.next(); it.remove(); @@ -265,16 +265,16 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param cursor the cursor to register */ - protected void registerCursor(Cursor cursor) { + protected void registerCursor(Cursor<E> cursor) { // We take this opportunity to clean the cursors list // of WeakReference objects to garbage-collected cursors. - for (Iterator it = cursors.iterator(); it.hasNext();) { - WeakReference ref = (WeakReference) it.next(); + for (Iterator<WeakReference<Cursor<E>>> it = cursors.iterator(); it.hasNext();) { + WeakReference<Cursor<E>> ref = it.next(); if (ref.get() == null) { it.remove(); } } - cursors.add(new WeakReference(cursor)); + cursors.add(new WeakReference<Cursor<E>>(cursor)); } /** @@ -282,16 +282,15 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param cursor the cursor to deregister */ - protected void unregisterCursor(Cursor cursor) { - for (Iterator it = cursors.iterator(); it.hasNext();) { - WeakReference ref = (WeakReference) it.next(); - Cursor cur = (Cursor) ref.get(); + protected void unregisterCursor(Cursor<E> cursor) { + for (Iterator<WeakReference<Cursor<E>>> it = cursors.iterator(); it.hasNext();) { + WeakReference<Cursor<E>> ref = it.next(); + Cursor<E> cur = ref.get(); if (cur == null) { // some other unrelated cursor object has been // garbage-collected; let's take the opportunity to // clean up the cursors list anyway.. it.remove(); - } else if (cur == cursor) { ref.clear(); it.remove(); @@ -307,11 +306,11 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param node the node that was changed */ - protected void broadcastNodeChanged(Node node) { - Iterator it = cursors.iterator(); + protected void broadcastNodeChanged(Node<E> node) { + Iterator<WeakReference<Cursor<E>>> it = cursors.iterator(); while (it.hasNext()) { - WeakReference ref = (WeakReference) it.next(); - Cursor cursor = (Cursor) ref.get(); + WeakReference<Cursor<E>> ref = it.next(); + Cursor<E> cursor = ref.get(); if (cursor == null) { it.remove(); // clean up list } else { @@ -326,11 +325,11 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param node the node that was changed */ - protected void broadcastNodeRemoved(Node node) { - Iterator it = cursors.iterator(); + protected void broadcastNodeRemoved(Node<E> node) { + Iterator<WeakReference<Cursor<E>>> it = cursors.iterator(); while (it.hasNext()) { - WeakReference ref = (WeakReference) it.next(); - Cursor cursor = (Cursor) ref.get(); + WeakReference<Cursor<E>> ref = it.next(); + Cursor<E> cursor = ref.get(); if (cursor == null) { it.remove(); // clean up list } else { @@ -345,11 +344,11 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param node the node that was changed */ - protected void broadcastNodeInserted(Node node) { - Iterator it = cursors.iterator(); + protected void broadcastNodeInserted(Node<E> node) { + Iterator<WeakReference<Cursor<E>>> it = cursors.iterator(); while (it.hasNext()) { - WeakReference ref = (WeakReference) it.next(); - Cursor cursor = (Cursor) ref.get(); + WeakReference<Cursor<E>> ref = it.next(); + Cursor<E> cursor = ref.get(); if (cursor == null) { it.remove(); // clean up list } else { @@ -382,8 +381,8 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * @param subList the sublist to get an iterator for * @param fromIndex the index to start from, relative to the sublist */ - protected ListIterator createSubListListIterator(LinkedSubList subList, int fromIndex) { - SubCursor cursor = new SubCursor(subList, fromIndex); + protected ListIterator<E> createSubListListIterator(LinkedSubList<E> subList, int fromIndex) { + SubCursor<E> cursor = new SubCursor<E>(subList, fromIndex); registerCursor(cursor); return cursor; } @@ -393,7 +392,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * An extended <code>ListIterator</code> that allows concurrent changes to * the underlying list. */ - public static class Cursor extends AbstractLinkedList.LinkedListIterator { + public static class Cursor<E> extends AbstractLinkedList.LinkedListIterator<E> { /** Is the cursor valid (not closed) */ boolean valid = true; /** Is the next index valid */ @@ -406,7 +405,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param index the index to start from */ - protected Cursor(CursorableLinkedList parent, int index) { + protected Cursor(CursorableLinkedList<E> parent, int index) { super(parent, index); valid = true; } @@ -443,7 +442,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param obj the object to add */ - public void add(Object obj) { + public void add(E obj) { // overridden, as the nodeInserted() method updates the iterator state super.add(obj); // matches the (next.previous == node) clause in nodeInserted() @@ -467,7 +466,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ nextIndex = parent.size(); } else { int pos = 0; - Node temp = parent.header.next; + Node<E> temp = parent.header.next; while (temp != next) { pos++; temp = temp.next; @@ -484,7 +483,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param node the node that changed */ - protected void nodeChanged(Node node) { + protected void nodeChanged(Node<E> node) { // do nothing } @@ -493,7 +492,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param node the node that was removed */ - protected void nodeRemoved(Node node) { + protected void nodeRemoved(Node<E> node) { if (node == next && node == current) { // state where next() followed by previous() next = node.next; @@ -521,7 +520,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @param node the node that was added */ - protected void nodeInserted(Node node) { + protected void nodeInserted(Node<E> node) { if (node.previous == current) { next = node; } else if (next.previous == node) { @@ -550,7 +549,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ */ public void close() { if (valid) { - ((CursorableLinkedList) parent).unregisterCursor(this); + ((CursorableLinkedList<E>) parent).unregisterCursor(this); valid = false; } } @@ -562,18 +561,18 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ * * @since Commons Collections 3.2 */ - protected static class SubCursor extends Cursor { + protected static class SubCursor<E> extends Cursor<E> { /** The parent list */ - protected final LinkedSubList sub; + protected final LinkedSubList<E> sub; /** * Constructs a new cursor. * * @param index the index to start from */ - protected SubCursor(LinkedSubList sub, int index) { - super((CursorableLinkedList) sub.parent, index + sub.offset); + protected SubCursor(LinkedSubList<E> sub, int index) { + super((CursorableLinkedList<E>) sub.parent, index + sub.offset); this.sub = sub; } @@ -589,7 +588,7 @@ public class CursorableLinkedList extends AbstractLinkedList implements Serializ return (super.nextIndex() - sub.offset); } - public void add(Object obj) { + public void add(E obj) { super.add(obj); sub.expectedModCount = parent.modCount; sub.size++; http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/FixedSizeList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/FixedSizeList.java b/src/java/org/apache/commons/collections/list/FixedSizeList.java index 8709bbe..65e0955 100644 --- a/src/java/org/apache/commons/collections/list/FixedSizeList.java +++ b/src/java/org/apache/commons/collections/list/FixedSizeList.java @@ -39,9 +39,9 @@ import org.apache.commons.collections.iterators.UnmodifiableIterator; * @author Stephen Colebourne * @author Paul Jack */ -public class FixedSizeList - extends AbstractSerializableListDecorator - implements BoundedCollection { +public class FixedSizeList<E> + extends AbstractSerializableListDecorator<E> + implements BoundedCollection<E> { /** Serialization version */ private static final long serialVersionUID = -2218010673611160319L; @@ -52,8 +52,8 @@ public class FixedSizeList * @param list the list to decorate, must not be null * @throws IllegalArgumentException if list is null */ - public static List decorate(List list) { - return new FixedSizeList(list); + public static <E> List<E> decorate(List<E> list) { + return new FixedSizeList<E>(list); } //----------------------------------------------------------------------- @@ -63,24 +63,24 @@ public class FixedSizeList * @param list the list to decorate, must not be null * @throws IllegalArgumentException if list is null */ - protected FixedSizeList(List list) { + protected FixedSizeList(List<E> list) { super(list); } //----------------------------------------------------------------------- - public boolean add(Object object) { + public boolean add(E object) { throw new UnsupportedOperationException("List is fixed size"); } - public void add(int index, Object object) { + public void add(int index, E object) { throw new UnsupportedOperationException("List is fixed size"); } - public boolean addAll(Collection coll) { + public boolean addAll(Collection<? extends E> coll) { throw new UnsupportedOperationException("List is fixed size"); } - public boolean addAll(int index, Collection coll) { + public boolean addAll(int index, Collection<? extends E> coll) { throw new UnsupportedOperationException("List is fixed size"); } @@ -88,7 +88,7 @@ public class FixedSizeList throw new UnsupportedOperationException("List is fixed size"); } - public Object get(int index) { + public E get(int index) { return decorated().get(index); } @@ -96,7 +96,7 @@ public class FixedSizeList return decorated().indexOf(object); } - public Iterator iterator() { + public Iterator<E> iterator() { return UnmodifiableIterator.decorate(decorated().iterator()); } @@ -104,15 +104,15 @@ public class FixedSizeList return decorated().lastIndexOf(object); } - public ListIterator listIterator() { + public ListIterator<E> listIterator() { return new FixedSizeListIterator(decorated().listIterator(0)); } - public ListIterator listIterator(int index) { + public ListIterator<E> listIterator(int index) { return new FixedSizeListIterator(decorated().listIterator(index)); } - public Object remove(int index) { + public E remove(int index) { throw new UnsupportedOperationException("List is fixed size"); } @@ -120,28 +120,28 @@ public class FixedSizeList throw new UnsupportedOperationException("List is fixed size"); } - public boolean removeAll(Collection coll) { + public boolean removeAll(Collection<?> coll) { throw new UnsupportedOperationException("List is fixed size"); } - public boolean retainAll(Collection coll) { + public boolean retainAll(Collection<?> coll) { throw new UnsupportedOperationException("List is fixed size"); } - public Object set(int index, Object object) { + public E set(int index, E object) { return decorated().set(index, object); } - public List subList(int fromIndex, int toIndex) { - List sub = decorated().subList(fromIndex, toIndex); - return new FixedSizeList(sub); + public List<E> subList(int fromIndex, int toIndex) { + List<E> sub = decorated().subList(fromIndex, toIndex); + return new FixedSizeList<E>(sub); } /** * List iterator that only permits changes via set() */ - static class FixedSizeListIterator extends AbstractListIteratorDecorator { - protected FixedSizeListIterator(ListIterator iterator) { + private class FixedSizeListIterator extends AbstractListIteratorDecorator<E> { + protected FixedSizeListIterator(ListIterator<E> iterator) { super(iterator); } public void remove() { http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/GrowthList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/GrowthList.java b/src/java/org/apache/commons/collections/list/GrowthList.java index ae2f652..bdf7c21 100644 --- a/src/java/org/apache/commons/collections/list/GrowthList.java +++ b/src/java/org/apache/commons/collections/list/GrowthList.java @@ -55,7 +55,7 @@ import java.util.List; * @author Stephen Colebourne * @author Paul Legato */ -public class GrowthList extends AbstractSerializableListDecorator { +public class GrowthList<E> extends AbstractSerializableListDecorator<E> { /** Serialization version */ private static final long serialVersionUID = -3620001881672L; @@ -66,8 +66,8 @@ public class GrowthList extends AbstractSerializableListDecorator { * @param list the list to decorate, must not be null * @throws IllegalArgumentException if list is null */ - public static List decorate(List list) { - return new GrowthList(list); + public static <E> List<E> decorate(List<E> list) { + return new GrowthList<E>(list); } //----------------------------------------------------------------------- @@ -75,7 +75,7 @@ public class GrowthList extends AbstractSerializableListDecorator { * Constructor that uses an ArrayList internally. */ public GrowthList() { - super(new ArrayList()); + super(new ArrayList<E>()); } /** @@ -85,7 +85,7 @@ public class GrowthList extends AbstractSerializableListDecorator { * @throws IllegalArgumentException if initial size is invalid */ public GrowthList(int initialSize) { - super(new ArrayList(initialSize)); + super(new ArrayList<E>(initialSize)); } /** @@ -94,7 +94,7 @@ public class GrowthList extends AbstractSerializableListDecorator { * @param list the list to decorate, must not be null * @throws IllegalArgumentException if list is null */ - protected GrowthList(List list) { + protected GrowthList(List<E> list) { super(list); } @@ -117,10 +117,10 @@ public class GrowthList extends AbstractSerializableListDecorator { * @throws ClassCastException if the underlying list rejects the element * @throws IllegalArgumentException if the underlying list rejects the element */ - public void add(int index, Object element) { + public void add(int index, E element) { int size = decorated().size(); if (index > size) { - decorated().addAll(Collections.nCopies(index - size, null)); + decorated().addAll(Collections.<E>nCopies(index - size, null)); } decorated().add(index, element); } @@ -145,11 +145,11 @@ public class GrowthList extends AbstractSerializableListDecorator { * @throws ClassCastException if the underlying list rejects the element * @throws IllegalArgumentException if the underlying list rejects the element */ - public boolean addAll(int index, Collection coll) { + public boolean addAll(int index, Collection<? extends E> coll) { int size = decorated().size(); boolean result = false; if (index > size) { - decorated().addAll(Collections.nCopies(index - size, null)); + decorated().addAll(Collections.<E>nCopies(index - size, null)); result = true; } return (decorated().addAll(index, coll) | result); @@ -175,10 +175,10 @@ public class GrowthList extends AbstractSerializableListDecorator { * @throws ClassCastException if the underlying list rejects the element * @throws IllegalArgumentException if the underlying list rejects the element */ - public Object set(int index, Object element) { + public E set(int index, E element) { int size = decorated().size(); if (index >= size) { - decorated().addAll(Collections.nCopies((index - size) + 1, null)); + decorated().addAll(Collections.<E>nCopies((index - size) + 1, null)); } return decorated().set(index, element); } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/LazyList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/LazyList.java b/src/java/org/apache/commons/collections/list/LazyList.java index ad83195..f1b11c3 100644 --- a/src/java/org/apache/commons/collections/list/LazyList.java +++ b/src/java/org/apache/commons/collections/list/LazyList.java @@ -61,13 +61,13 @@ import org.apache.commons.collections.Factory; * @author Arron Bates * @author Paul Jack */ -public class LazyList extends AbstractSerializableListDecorator { +public class LazyList<E> extends AbstractSerializableListDecorator<E> { /** Serialization version */ private static final long serialVersionUID = -1708388017160694542L; /** The factory to use to lazily instantiate the objects */ - protected final Factory factory; + protected final Factory<? extends E> factory; /** * Factory method to create a lazily instantiating list. @@ -76,8 +76,8 @@ public class LazyList extends AbstractSerializableListDecorator { * @param factory the factory to use for creation, must not be null * @throws IllegalArgumentException if list or factory is null */ - public static List decorate(List list, Factory factory) { - return new LazyList(list, factory); + public static <E> List<E> decorate(List<E> list, Factory<? extends E> factory) { + return new LazyList<E>(list, factory); } //----------------------------------------------------------------------- @@ -88,7 +88,7 @@ public class LazyList extends AbstractSerializableListDecorator { * @param factory the factory to use for creation, must not be null * @throws IllegalArgumentException if list or factory is null */ - protected LazyList(List list, Factory factory) { + protected LazyList(List<E> list, Factory<? extends E> factory) { super(list); if (factory == null) { throw new IllegalArgumentException("Factory must not be null"); @@ -107,36 +107,33 @@ public class LazyList extends AbstractSerializableListDecorator { * * @param index the index to retrieve */ - public Object get(int index) { + public E get(int index) { int size = decorated().size(); if (index < size) { // within bounds, get the object - Object object = decorated().get(index); + E object = decorated().get(index); if (object == null) { // item is a place holder, create new one, set and return object = factory.create(); decorated().set(index, object); return object; - } else { - // good and ready to go - return object; - } - } else { - // we have to grow the list - for (int i = size; i < index; i++) { - decorated().add(null); } - // create our last object, set and return - Object object = factory.create(); - decorated().add(object); + // good and ready to go return object; } + // we have to grow the list + for (int i = size; i < index; i++) { + decorated().add(null); + } + // create our last object, set and return + E object = factory.create(); + decorated().add(object); + return object; } - - public List subList(int fromIndex, int toIndex) { - List sub = decorated().subList(fromIndex, toIndex); - return new LazyList(sub, factory); + public List<E> subList(int fromIndex, int toIndex) { + List<E> sub = decorated().subList(fromIndex, toIndex); + return new LazyList<E>(sub, factory); } } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/NodeCachingLinkedList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/NodeCachingLinkedList.java b/src/java/org/apache/commons/collections/list/NodeCachingLinkedList.java index f997043..0b5a13f 100644 --- a/src/java/org/apache/commons/collections/list/NodeCachingLinkedList.java +++ b/src/java/org/apache/commons/collections/list/NodeCachingLinkedList.java @@ -44,7 +44,7 @@ import java.util.Collection; * @author Phil Steitz * @author Stephen Colebourne */ -public class NodeCachingLinkedList extends AbstractLinkedList implements Serializable { +public class NodeCachingLinkedList<E> extends AbstractLinkedList<E> implements Serializable { /** Serialization version */ private static final long serialVersionUID = 6897789178562232073L; @@ -59,7 +59,7 @@ public class NodeCachingLinkedList extends AbstractLinkedList implements Seriali * Cached nodes are stored in a singly-linked list with * <code>next</code> pointing to the next element. */ - protected transient Node firstCachedNode; + protected transient Node<E> firstCachedNode; /** * The size of the cache. @@ -84,7 +84,7 @@ public class NodeCachingLinkedList extends AbstractLinkedList implements Seriali * * @param coll the collection to copy */ - public NodeCachingLinkedList(Collection coll) { + public NodeCachingLinkedList(Collection<E> coll) { super(coll); this.maximumCacheSize = DEFAULT_MAXIMUM_CACHE_SIZE; } @@ -137,11 +137,11 @@ public class NodeCachingLinkedList extends AbstractLinkedList implements Seriali * * @return a node, or <code>null</code> if there are no nodes in the cache. */ - protected Node getNodeFromCache() { + protected Node<E> getNodeFromCache() { if (cacheSize == 0) { return null; } - Node cachedNode = firstCachedNode; + Node<E> cachedNode = firstCachedNode; firstCachedNode = cachedNode.next; cachedNode.next = null; // This should be changed anyway, but defensively // set it to null. @@ -164,13 +164,13 @@ public class NodeCachingLinkedList extends AbstractLinkedList implements Seriali * * @param node the node to add to the cache */ - protected void addNodeToCache(Node node) { + protected void addNodeToCache(Node<E> node) { if (isCacheFull()) { // don't cache the node. return; } // clear the node's contents and add it to the cache. - Node nextCachedNode = firstCachedNode; + Node<E> nextCachedNode = firstCachedNode; node.previous = null; node.next = nextCachedNode; node.setValue(null); @@ -186,14 +186,13 @@ public class NodeCachingLinkedList extends AbstractLinkedList implements Seriali * @param value value of the new node * @return the newly created node */ - protected Node createNode(Object value) { - Node cachedNode = getNodeFromCache(); + protected Node<E> createNode(E value) { + Node<E> cachedNode = getNodeFromCache(); if (cachedNode == null) { return super.createNode(value); - } else { - cachedNode.setValue(value); - return cachedNode; } + cachedNode.setValue(value); + return cachedNode; } /** @@ -202,7 +201,7 @@ public class NodeCachingLinkedList extends AbstractLinkedList implements Seriali * * @param node the node to remove */ - protected void removeNode(Node node) { + protected void removeNode(Node<E> node) { super.removeNode(node); addNodeToCache(node); } @@ -218,9 +217,9 @@ public class NodeCachingLinkedList extends AbstractLinkedList implements Seriali // {@link AbstractLinkedList.removeAllNodes()} removes the // nodes by removing references directly from {@link #header}. int numberOfNodesToCache = Math.min(size, maximumCacheSize - cacheSize); - Node node = header.next; + Node<E> node = header.next; for (int currentIndex = 0; currentIndex < numberOfNodesToCache; currentIndex++) { - Node oldNode = node; + Node<E> oldNode = node; node = node.next; addNodeToCache(oldNode); } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/SetUniqueList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/SetUniqueList.java b/src/java/org/apache/commons/collections/list/SetUniqueList.java index f70311c..cc32cbf 100644 --- a/src/java/org/apache/commons/collections/list/SetUniqueList.java +++ b/src/java/org/apache/commons/collections/list/SetUniqueList.java @@ -5,9 +5,9 @@ * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -46,12 +46,12 @@ import org.apache.commons.collections.set.UnmodifiableSet; * * @since Commons Collections 3.0 * @version $Revision$ $Date$ - * + * * @author Matthew Hawthorne * @author Stephen Colebourne * @author Tom Dunham */ -public class SetUniqueList extends AbstractSerializableListDecorator { +public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> { /** Serialization version */ private static final long serialVersionUID = 7196982186153478694L; @@ -59,30 +59,29 @@ public class SetUniqueList extends AbstractSerializableListDecorator { /** * Internal Set to maintain uniqueness. */ - protected final Set set; + protected final Set<E> set; /** * Factory method to create a SetList using the supplied list to retain order. * <p> * If the list contains duplicates, these are removed (first indexed one kept). * A <code>HashSet</code> is used for the set behaviour. - * + * * @param list the list to decorate, must not be null * @throws IllegalArgumentException if list is null */ - public static SetUniqueList decorate(List list) { + public static <E> SetUniqueList<E> decorate(List<E> list) { if (list == null) { throw new IllegalArgumentException("List must not be null"); } if (list.isEmpty()) { - return new SetUniqueList(list, new HashSet()); - } else { - List temp = new ArrayList(list); - list.clear(); - SetUniqueList sl = new SetUniqueList(list, new HashSet()); - sl.addAll(temp); - return sl; + return new SetUniqueList<E>(list, new HashSet<E>()); } + List<E> temp = new ArrayList<E>(list); + list.clear(); + SetUniqueList<E> sl = new SetUniqueList<E>(list, new HashSet<E>()); + sl.addAll(temp); + return sl; } //----------------------------------------------------------------------- @@ -90,12 +89,12 @@ public class SetUniqueList extends AbstractSerializableListDecorator { * Constructor that wraps (not copies) the List and specifies the set 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 SetUniqueList(List list, Set set) { + protected SetUniqueList(List<E> list, Set<E> set) { super(list); if (set == null) { throw new IllegalArgumentException("Set must not be null"); @@ -106,10 +105,10 @@ public class SetUniqueList extends AbstractSerializableListDecorator { //----------------------------------------------------------------------- /** * Gets an unmodifiable view as a Set. - * + * * @return an unmodifiable set view */ - public Set asSet() { + public Set<E> asSet() { return UnmodifiableSet.decorate(set); } @@ -121,11 +120,11 @@ public class SetUniqueList extends AbstractSerializableListDecorator { * The <code>List</code> interface requires that this method returns * <code>true</code> always. However this class may return <code>false</code> * because of the <code>Set</code> behaviour. - * + * * @param object the object to add * @return true if object was added */ - public boolean add(Object object) { + public boolean add(E object) { // gets initial size final int sizeBefore = size(); @@ -142,11 +141,11 @@ public class SetUniqueList extends AbstractSerializableListDecorator { * <i>(Violation)</i> * The <code>List</code> interface makes the assumption that the element is * always inserted. This may not happen with this implementation. - * + * * @param index the index to insert at * @param object the object to add */ - public void add(int index, Object object) { + public void add(int index, E object) { // adds element if it is not contained already if (set.contains(object) == false) { super.add(index, object); @@ -160,10 +159,10 @@ public class SetUniqueList extends AbstractSerializableListDecorator { * <i>(Violation)</i> * The <code>List</code> interface makes the assumption that the element is * always inserted. This may not happen with this implementation. - * + * * @param coll the collection to add */ - public boolean addAll(Collection coll) { + public boolean addAll(Collection<? extends E> coll) { return addAll(size(), coll); } @@ -176,22 +175,24 @@ public class SetUniqueList extends AbstractSerializableListDecorator { * <i>(Violation)</i> * The <code>List</code> interface makes the assumption that the elements * are always inserted. This may not happen with this implementation. - * + * * @param index the index to insert at * @param coll the collection to add in iterator order * @return true if this collection changed */ - public boolean addAll(int index, Collection coll) { - // gets initial size - final int sizeBefore = size(); - - // adds all elements - for (final Iterator it = coll.iterator(); it.hasNext();) { - add(it.next()); + public boolean addAll(int index, Collection<? extends E> coll) { + HashSet<E> temp = new HashSet<E>(coll); + temp.removeAll(set); + if (temp.isEmpty()) { + return false; } - - // compares sizes to detect if collection changed - return sizeBefore != size(); + for (E e : coll) { + if (temp.contains(e)) { + add(index, e); + index++; + } + } + return true; } //----------------------------------------------------------------------- @@ -202,18 +203,18 @@ public class SetUniqueList extends AbstractSerializableListDecorator { * Afterwards, any previous duplicate is removed * If the object is not already in the list then a normal set occurs. * If it is present, then the old version is removed. - * + * * @param index the index to insert at * @param object the object to set * @return the previous object */ - public Object set(int index, Object object) { + public E set(int index, E object) { int pos = indexOf(object); - Object removed = super.set(index, object); + E removed = super.set(index, object); if (pos == -1 || pos == index) { return removed; } - + // the object is already in the uniq list // (and it hasn't been swapped with itself) super.remove(pos); // remove the duplicate by index @@ -227,19 +228,19 @@ public class SetUniqueList extends AbstractSerializableListDecorator { return result; } - public Object remove(int index) { - Object result = super.remove(index); + public E remove(int index) { + E result = super.remove(index); set.remove(result); return result; } - public boolean removeAll(Collection coll) { + public boolean removeAll(Collection<?> coll) { boolean result = super.removeAll(coll); set.removeAll(coll); return result; } - public boolean retainAll(Collection coll) { + public boolean retainAll(Collection<?> coll) { boolean result = super.retainAll(coll); set.retainAll(coll); return result; @@ -254,41 +255,61 @@ public class SetUniqueList extends AbstractSerializableListDecorator { return set.contains(object); } - public boolean containsAll(Collection coll) { + public boolean containsAll(Collection<?> coll) { return set.containsAll(coll); } - public Iterator iterator() { - return new SetListIterator(super.iterator(), set); + public Iterator<E> iterator() { + return new SetListIterator<E>(super.iterator(), set); + } + + public ListIterator<E> listIterator() { + return new SetListListIterator<E>(super.listIterator(), set); } - public ListIterator listIterator() { - return new SetListListIterator(super.listIterator(), set); + public ListIterator<E> listIterator(int index) { + return new SetListListIterator<E>(super.listIterator(index), set); } - public ListIterator listIterator(int index) { - return new SetListListIterator(super.listIterator(index), set); + public List<E> subList(int fromIndex, int toIndex) { + List<E> superSubList = super.subList(fromIndex, toIndex); + Set<E> subSet = createSetBasedOnList(set, superSubList); + return new SetUniqueList<E>(superSubList, subSet); } - public List subList(int fromIndex, int toIndex) { - return new SetUniqueList(super.subList(fromIndex, toIndex), set); + @SuppressWarnings("unchecked") + protected Set<E> createSetBasedOnList(Set<E> set, List<E> list) { + Set<E> subSet = null; + if (set.getClass().equals(HashSet.class)) { + subSet = new HashSet<E>(); + } else { + try { + subSet = (Set<E>) set.getClass().newInstance(); + } catch (InstantiationException ie) { + subSet = new HashSet<E>(); + } catch (IllegalAccessException iae) { + subSet = new HashSet<E>(); + } + } + subSet.addAll(list); + return subSet; } //----------------------------------------------------------------------- /** * Inner class iterator. */ - static class SetListIterator extends AbstractIteratorDecorator { - - protected final Set set; - protected Object last = null; - - protected SetListIterator(Iterator it, Set set) { + static class SetListIterator<E> extends AbstractIteratorDecorator<E> { + + protected final Set<E> set; + protected E last = null; + + protected SetListIterator(Iterator<E> it, Set<E> set) { super(it); this.set = set; } - - public Object next() { + + public E next() { last = super.next(); return last; } @@ -299,26 +320,26 @@ public class SetUniqueList extends AbstractSerializableListDecorator { last = null; } } - + /** * Inner class iterator. */ - static class SetListListIterator extends AbstractListIteratorDecorator { - - protected final Set set; - protected Object last = null; - - protected SetListListIterator(ListIterator it, Set set) { + static class SetListListIterator<E> extends AbstractListIteratorDecorator<E> { + + protected final Set<E> set; + protected E last = null; + + protected SetListListIterator(ListIterator<E> it, Set<E> set) { super(it); this.set = set; } - - public Object next() { + + public E next() { last = super.next(); return last; } - public Object previous() { + public E previous() { last = super.previous(); return last; } @@ -329,16 +350,16 @@ public class SetUniqueList extends AbstractSerializableListDecorator { last = null; } - public void add(Object object) { + public void add(E object) { if (set.contains(object) == false) { super.add(object); set.add(object); } } - - public void set(Object object) { + + public void set(E object) { throw new UnsupportedOperationException("ListIterator does not support set"); } } - + } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/list/SynchronizedList.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/list/SynchronizedList.java b/src/java/org/apache/commons/collections/list/SynchronizedList.java index e6f255c..a01e656 100644 --- a/src/java/org/apache/commons/collections/list/SynchronizedList.java +++ b/src/java/org/apache/commons/collections/list/SynchronizedList.java @@ -122,7 +122,7 @@ public class SynchronizedList<E> extends SynchronizedCollection<E> implements Li * * @return an iterator that must be manually synchronized on the collection */ - public ListIterator listIterator() { + public ListIterator<E> listIterator() { return getList().listIterator(); } @@ -136,7 +136,7 @@ public class SynchronizedList<E> extends SynchronizedCollection<E> implements Li * * @return an iterator that must be manually synchronized on the collection */ - public ListIterator listIterator(int index) { + public ListIterator<E> listIterator(int index) { return getList().listIterator(index); }
