commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bay...@apache.org
Subject svn commit: r815061 - /commons/proper/collections/trunk/src/java/org/apache/commons/collections/IteratorUtils.java
Date Tue, 15 Sep 2009 05:55:34 GMT
Author: bayard
Date: Tue Sep 15 05:55:33 2009
New Revision: 815061

URL: http://svn.apache.org/viewvc?rev=815061&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:

    ------------------------------------------------------------------------
    r753392 | mbenson | 2009-03-13 13:39:53 -0700 (Fri, 13 Mar 2009) | 1 line
    
    revert IteratorUtils stuff; toList() works fine for this--duh
    ------------------------------------------------------------------------
    r751850 | mbenson | 2009-03-09 14:34:44 -0700 (Mon, 09 Mar 2009) | 1 line
    
    add iterable(Iterator)
    ------------------------------------------------------------------------

Modified:
    commons/proper/collections/trunk/src/java/org/apache/commons/collections/IteratorUtils.java

Modified: commons/proper/collections/trunk/src/java/org/apache/commons/collections/IteratorUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/trunk/src/java/org/apache/commons/collections/IteratorUtils.java?rev=815061&r1=815060&r2=815061&view=diff
==============================================================================
--- commons/proper/collections/trunk/src/java/org/apache/commons/collections/IteratorUtils.java
(original)
+++ commons/proper/collections/trunk/src/java/org/apache/commons/collections/IteratorUtils.java
Tue Sep 15 05:55:33 2009
@@ -55,7 +55,7 @@
 import org.apache.commons.collections.iterators.UnmodifiableMapIterator;
 
 /**
- * Provides static utility methods and decorators for {@link Iterator} 
+ * Provides static utility methods and decorators for {@link Iterator}
  * instances. The implementations are provided in the iterators subpackage.
  * <p>
  * WARNING: Due to human error certain binary incompatabilities were introduced
@@ -81,26 +81,30 @@
      * WARNING: This constant is binary incompatible with Commons Collections 2.1 and 2.1.1.
      * Use <code>EmptyIterator.INSTANCE</code> for compatability with Commons
Collections 2.1.1.
      */
-    public static final ResettableIterator EMPTY_ITERATOR = EmptyIterator.RESETTABLE_INSTANCE;
+    public static final ResettableIterator<Object> EMPTY_ITERATOR = EmptyIterator.RESETTABLE_INSTANCE;
+
     /**
      * A list iterator over no elements.
      * <p>
      * WARNING: This constant is binary incompatible with Commons Collections 2.1 and 2.1.1.
      * Use <code>EmptyListIterator.INSTANCE</code> for compatability with Commons
Collections 2.1.1.
      */
-    public static final ResettableListIterator EMPTY_LIST_ITERATOR = EmptyListIterator.RESETTABLE_INSTANCE;
+    public static final ResettableListIterator<Object> EMPTY_LIST_ITERATOR = EmptyListIterator.RESETTABLE_INSTANCE;
+
     /**
      * An ordered iterator over no elements.
-     */    
-    public static final OrderedIterator EMPTY_ORDERED_ITERATOR = EmptyOrderedIterator.INSTANCE;
+     */
+    public static final OrderedIterator<Object> EMPTY_ORDERED_ITERATOR = EmptyOrderedIterator.INSTANCE;
+
     /**
      * A map iterator over no elements.
-     */    
-    public static final MapIterator EMPTY_MAP_ITERATOR = EmptyMapIterator.INSTANCE;
+     */
+    public static final MapIterator<Object, Object> EMPTY_MAP_ITERATOR = EmptyMapIterator.INSTANCE;
+
     /**
      * An ordered map iterator over no elements.
-     */    
-    public static final OrderedMapIterator EMPTY_ORDERED_MAP_ITERATOR = EmptyOrderedMapIterator.INSTANCE;
+     */
+    public static final OrderedMapIterator<Object, Object> EMPTY_ORDERED_MAP_ITERATOR
= EmptyOrderedMapIterator.INSTANCE;
 
     /**
      * IteratorUtils is not normally instantiated.
@@ -121,14 +125,14 @@
      *
      * @return  an iterator over nothing
      */
-    public static ResettableIterator emptyIterator() {
-        return EMPTY_ITERATOR;
+    public static <E> ResettableIterator<E> emptyIterator() {
+        return EmptyIterator.<E>getResettableInstance();
     }
 
     /**
      * Gets an empty list iterator.
      * <p>
-     * This iterator is a valid list iterator object that will iterate 
+     * This iterator is a valid list iterator object that will iterate
      * over nothing.
      * <p>
      * WARNING: This method is binary incompatible with Commons Collections 2.1 and 2.1.1.
@@ -136,44 +140,44 @@
      *
      * @return  a list iterator over nothing
      */
-    public static ResettableListIterator emptyListIterator() {
-        return EMPTY_LIST_ITERATOR;
+    public static <E> ResettableListIterator<E> emptyListIterator() {
+        return EmptyListIterator.<E>getResettableInstance();
     }
 
     /**
      * Gets an empty ordered iterator.
      * <p>
-     * This iterator is a valid iterator object that will iterate 
+     * This iterator is a valid iterator object that will iterate
      * over nothing.
      *
      * @return  an ordered iterator over nothing
      */
-    public static OrderedIterator emptyOrderedIterator() {
-        return EMPTY_ORDERED_ITERATOR;
+    public static <E> OrderedIterator<E> emptyOrderedIterator() {
+        return EmptyOrderedIterator.<E>getInstance();
     }
 
     /**
      * Gets an empty map iterator.
      * <p>
-     * This iterator is a valid map iterator object that will iterate 
+     * This iterator is a valid map iterator object that will iterate
      * over nothing.
      *
      * @return  a map iterator over nothing
      */
-    public static MapIterator emptyMapIterator() {
-        return EMPTY_MAP_ITERATOR;
+    public static <K, V> MapIterator<K, V> emptyMapIterator() {
+        return EmptyMapIterator.<K, V>getInstance();
     }
 
     /**
      * Gets an empty ordered map iterator.
      * <p>
-     * This iterator is a valid map iterator object that will iterate 
+     * This iterator is a valid map iterator object that will iterate
      * over nothing.
      *
      * @return  a map iterator over nothing
      */
-    public static OrderedMapIterator emptyOrderedMapIterator() {
-        return EMPTY_ORDERED_MAP_ITERATOR;
+    public static <K, V> OrderedMapIterator<K, V> emptyOrderedMapIterator() {
+        return EmptyOrderedMapIterator.<K, V>getInstance();
     }
 
     // Singleton
@@ -190,8 +194,8 @@
      * @param object  the single object over which to iterate
      * @return  a singleton iterator over the object
      */
-    public static ResettableIterator singletonIterator(Object object) {
-        return new SingletonIterator(object);
+    public static <E> ResettableIterator<E> singletonIterator(E object) {
+        return new SingletonIterator<E>(object);
     }
 
     /**
@@ -203,8 +207,8 @@
      * @param object  the single object over which to iterate
      * @return  a singleton list iterator over the object
      */
-    public static ListIterator singletonListIterator(Object object) {
-        return new SingletonListIterator(object);
+    public static <E> ListIterator<E> singletonListIterator(E object) {
+        return new SingletonListIterator<E>(object);
     }
 
     // Arrays
@@ -219,8 +223,8 @@
      * @return  an iterator over the array
      * @throws NullPointerException if array is null
      */
-    public static ResettableIterator arrayIterator(Object[] array) {
-        return new ObjectArrayIterator(array);
+    public static <E> ResettableIterator<E> arrayIterator(E[] array) {
+        return new ObjectArrayIterator<E>(array);
     }
 
     /**
@@ -234,8 +238,8 @@
      * @throws IllegalArgumentException if the array is not an array
      * @throws NullPointerException if array is null
      */
-    public static ResettableIterator arrayIterator(Object array) {
-        return new ArrayIterator(array);
+    public static <E> ResettableIterator<E> arrayIterator(Object array) {
+        return new ArrayIterator<E>(array);
     }
 
     /**
@@ -251,8 +255,8 @@
      *  than the length of the array
      * @throws NullPointerException if array is null
      */
-    public static ResettableIterator arrayIterator(Object[] array, int start) {
-        return new ObjectArrayIterator(array, start);
+    public static <E> ResettableIterator<E> arrayIterator(E[] array, int start)
{
+        return new ObjectArrayIterator<E>(array, start);
     }
 
     /**
@@ -269,8 +273,8 @@
      *  than the length of the array
      * @throws NullPointerException if array is null
      */
-    public static ResettableIterator arrayIterator(Object array, int start) {
-        return new ArrayIterator(array, start);
+    public static <E> ResettableIterator<E> arrayIterator(Object array, int start)
{
+        return new ArrayIterator<E>(array, start);
     }
 
     /**
@@ -287,8 +291,8 @@
      * @throws IllegalArgumentException if end is before start
      * @throws NullPointerException if array is null
      */
-    public static ResettableIterator arrayIterator(Object[] array, int start, int end) {
-        return new ObjectArrayIterator(array, start, end);
+    public static <E> ResettableIterator<E> arrayIterator(E[] array, int start,
int end) {
+        return new ObjectArrayIterator<E>(array, start, end);
     }
 
     /**
@@ -306,8 +310,8 @@
      * @throws IllegalArgumentException if end is before start
      * @throws NullPointerException if array is null
      */
-    public static ResettableIterator arrayIterator(Object array, int start, int end) {
-        return new ArrayIterator(array, start, end);
+    public static <E> ResettableIterator<E> arrayIterator(Object array, int start,
int end) {
+        return new ArrayIterator<E>(array, start, end);
     }
 
     //-----------------------------------------------------------------------
@@ -318,8 +322,8 @@
      * @return  a list iterator over the array
      * @throws NullPointerException if array is null
      */
-    public static ResettableListIterator arrayListIterator(Object[] array) {
-        return new ObjectArrayListIterator(array);
+    public static <E> ResettableListIterator<E> arrayListIterator(E[] array)
{
+        return new ObjectArrayListIterator<E>(array);
     }
 
     /**
@@ -333,8 +337,8 @@
      * @throws IllegalArgumentException if the array is not an array
      * @throws NullPointerException if array is null
      */
-    public static ResettableListIterator arrayListIterator(Object array) {
-        return new ArrayListIterator(array);
+    public static <E> ResettableListIterator<E> arrayListIterator(Object array)
{
+        return new ArrayListIterator<E>(array);
     }
 
     /**
@@ -346,8 +350,8 @@
      * @throws IndexOutOfBoundsException if start is less than zero
      * @throws NullPointerException if array is null
      */
-    public static ResettableListIterator arrayListIterator(Object[] array, int start) {
-        return new ObjectArrayListIterator(array, start);
+    public static <E> ResettableListIterator<E> arrayListIterator(E[] array,
int start) {
+        return new ObjectArrayListIterator<E>(array, start);
     }
 
     /**
@@ -363,8 +367,8 @@
      * @throws IndexOutOfBoundsException if start is less than zero
      * @throws NullPointerException if array is null
      */
-    public static ResettableListIterator arrayListIterator(Object array, int start) {
-        return new ArrayListIterator(array, start);
+    public static <E> ResettableListIterator<E> arrayListIterator(Object array,
int start) {
+        return new ArrayListIterator<E>(array, start);
     }
 
     /**
@@ -378,10 +382,10 @@
      * @throws IllegalArgumentException if end is before start
      * @throws NullPointerException if array is null
      */
-    public static ResettableListIterator arrayListIterator(Object[] array, int start, int
end) {
-        return new ObjectArrayListIterator(array, start, end);
+    public static <E> ResettableListIterator<E> arrayListIterator(E[] array,
int start, int end) {
+        return new ObjectArrayListIterator<E>(array, start, end);
     }
-    
+
     /**
      * Gets a list iterator over part of an object or primitive array.
      * <p>
@@ -397,10 +401,10 @@
      * @throws IllegalArgumentException if end is before start
      * @throws NullPointerException if array is null
      */
-    public static ResettableListIterator arrayListIterator(Object array, int start, int end)
{
-        return new ArrayListIterator(array, start, end);
+    public static <E> ResettableListIterator<E> arrayListIterator(Object array,
int start, int end) {
+        return new ArrayListIterator<E>(array, start, end);
     }
-    
+
     // Unmodifiable
     //-----------------------------------------------------------------------
     /**
@@ -411,10 +415,10 @@
      * @param iterator  the iterator to make immutable
      * @return an immutable version of the iterator
      */
-    public static Iterator unmodifiableIterator(Iterator iterator) {
+    public static <E> Iterator<E> unmodifiableIterator(Iterator<E> iterator)
{
         return UnmodifiableIterator.decorate(iterator);
     }
-    
+
     /**
      * Gets an immutable version of a {@link ListIterator}. The returned object
      * will always throw an {@link UnsupportedOperationException} for
@@ -424,7 +428,7 @@
      * @param listIterator  the iterator to make immutable
      * @return an immutable version of the iterator
      */
-    public static ListIterator unmodifiableListIterator(ListIterator listIterator) {
+    public static <E> ListIterator<E> unmodifiableListIterator(ListIterator<E>
listIterator) {
         return UnmodifiableListIterator.decorate(listIterator);
     }
 
@@ -436,14 +440,14 @@
      * @param mapIterator  the iterator to make immutable
      * @return an immutable version of the iterator
      */
-    public static MapIterator unmodifiableMapIterator(MapIterator mapIterator) {
+    public static <K, V> MapIterator<K, V> unmodifiableMapIterator(MapIterator<K,
V> mapIterator) {
         return UnmodifiableMapIterator.decorate(mapIterator);
     }
 
     // Chained
     //-----------------------------------------------------------------------
     /**
-     * Gets an iterator that iterates through two {@link Iterator}s 
+     * Gets an iterator that iterates through two {@link Iterator}s
      * one after another.
      *
      * @param iterator1  the first iterators to use, not null
@@ -451,24 +455,24 @@
      * @return a combination iterator over the iterators
      * @throws NullPointerException if either iterator is null
      */
-    public static Iterator chainedIterator(Iterator iterator1, Iterator iterator2) {
-        return new IteratorChain(iterator1, iterator2);
+    public static <E> Iterator<E> chainedIterator(Iterator<? extends E>
iterator1, Iterator<? extends E> iterator2) {
+        return new IteratorChain<E>(iterator1, iterator2);
     }
 
     /**
-     * Gets an iterator that iterates through an array of {@link Iterator}s 
+     * Gets an iterator that iterates through an array of {@link Iterator}s
      * one after another.
      *
      * @param iterators  the iterators to use, not null or empty or contain nulls
      * @return a combination iterator over the iterators
      * @throws NullPointerException if iterators array is null or contains a null
      */
-    public static Iterator chainedIterator(Iterator[] iterators) {
-        return new IteratorChain(iterators);
+    public static <E> Iterator<E> chainedIterator(Iterator<? extends E>[]
iterators) {
+        return new IteratorChain<E>(iterators);
     }
 
     /**
-     * Gets an iterator that iterates through a collections of {@link Iterator}s 
+     * Gets an iterator that iterates through a collections of {@link Iterator}s
      * one after another.
      *
      * @param iterators  the iterators to use, not null or empty or contain nulls
@@ -476,8 +480,8 @@
      * @throws NullPointerException if iterators collection is null or contains a null
      * @throws ClassCastException if the iterators collection contains the wrong object type
      */
-    public static Iterator chainedIterator(Collection iterators) {
-        return new IteratorChain(iterators);
+    public static <E> Iterator<E> chainedIterator(Collection<Iterator<?
extends E>> iterators) {
+        return new IteratorChain<E>(iterators);
     }
 
     // Collated
@@ -487,7 +491,7 @@
      * contained in a collection of ordered {@link Iterator}s.
      * <p>
      * Given two ordered {@link Iterator}s <code>A</code> and <code>B</code>,
-     * the {@link Iterator#next()} method will return the lesser of 
+     * the {@link Iterator#next()} method will return the lesser of
      * <code>A.next()</code> and <code>B.next()</code>.
      * <p>
      * The comparator is optional. If null is specified then natural order is used.
@@ -498,8 +502,8 @@
      * @return a combination iterator over the iterators
      * @throws NullPointerException if either iterator is null
      */
-    public static Iterator collatedIterator(Comparator comparator, Iterator iterator1, Iterator
iterator2) {
-        return new CollatingIterator(comparator, iterator1, iterator2);
+    public static <E> Iterator<E> collatedIterator(Comparator<? super E>
comparator, Iterator<? extends E> iterator1, Iterator<? extends E> iterator2)
{
+        return new CollatingIterator<E>(comparator, iterator1, iterator2);
     }
 
     /**
@@ -507,7 +511,7 @@
      * contained in an array of {@link Iterator}s.
      * <p>
      * Given two ordered {@link Iterator}s <code>A</code> and <code>B</code>,
-     * the {@link Iterator#next()} method will return the lesser of 
+     * the {@link Iterator#next()} method will return the lesser of
      * <code>A.next()</code> and <code>B.next()</code> and so on.
      * <p>
      * The comparator is optional. If null is specified then natural order is used.
@@ -517,8 +521,8 @@
      * @return a combination iterator over the iterators
      * @throws NullPointerException if iterators array is null or contains a null
      */
-    public static Iterator collatedIterator(Comparator comparator, Iterator[] iterators)
{
-        return new CollatingIterator(comparator, iterators);
+    public static <E> Iterator<E> collatedIterator(Comparator<? super E>
comparator, Iterator<? extends E>[] iterators) {
+        return new CollatingIterator<E>(comparator, iterators);
     }
 
     /**
@@ -526,7 +530,7 @@
      * contained in a collection of {@link Iterator}s.
      * <p>
      * Given two ordered {@link Iterator}s <code>A</code> and <code>B</code>,
-     * the {@link Iterator#next()} method will return the lesser of 
+     * the {@link Iterator#next()} method will return the lesser of
      * <code>A.next()</code> and <code>B.next()</code> and so on.
      * <p>
      * The comparator is optional. If null is specified then natural order is used.
@@ -537,10 +541,11 @@
      * @throws NullPointerException if iterators collection is null or contains a null
      * @throws ClassCastException if the iterators collection contains the wrong object type
      */
-    public static Iterator collatedIterator(Comparator comparator, Collection iterators)
{
-        return new CollatingIterator(comparator, iterators);
+    public static <E> Iterator<E> collatedIterator(Comparator<? super E>
comparator,
+            Collection<Iterator<? extends E>> iterators) {
+        return new CollatingIterator<E>(comparator, iterators);
     }
-    
+
     // Object Graph
     //-----------------------------------------------------------------------
     /**
@@ -590,16 +595,16 @@
      * <p>
      * Under many circumstances, linking Iterators together in this manner is
      * more efficient (and convenient) than using nested for loops to extract a list.
-     * 
+     *
      * @param root  the root object to start iterating from, null results in an empty iterator
      * @param transformer  the transformer to use, see above, null uses no effect transformer
      * @return a new object graph iterator
      * @since Commons Collections 3.1
      */
-    public static Iterator objectGraphIterator(Object root, Transformer transformer) {
-        return new ObjectGraphIterator(root, transformer);
+    public static <E> Iterator<E> objectGraphIterator(E root, Transformer<?
super E, ? extends E> transformer) {
+        return new ObjectGraphIterator<E>(root, transformer);
     }
-    
+
     // Transformed
     //-----------------------------------------------------------------------
     /**
@@ -613,16 +618,16 @@
      * @return a new transforming iterator
      * @throws NullPointerException if either parameter is null
      */
-    public static Iterator transformedIterator(Iterator iterator, Transformer transform)
{
+    public static <I, O> Iterator<O> transformedIterator(Iterator<? extends
I> iterator, Transformer<? super I, ? extends O> transform) {
         if (iterator == null) {
             throw new NullPointerException("Iterator must not be null");
         }
         if (transform == null) {
             throw new NullPointerException("Transformer must not be null");
         }
-        return new TransformIterator(iterator, transform);
+        return new TransformIterator<I, O>(iterator, transform);
     }
-    
+
     // Filtered
     //-----------------------------------------------------------------------
     /**
@@ -636,16 +641,16 @@
      * @return a new filtered iterator
      * @throws NullPointerException if either parameter is null
      */
-    public static Iterator filteredIterator(Iterator iterator, Predicate predicate) {
+    public static <E> Iterator<E> filteredIterator(Iterator<? extends E>
iterator, Predicate<? super E> predicate) {
         if (iterator == null) {
             throw new NullPointerException("Iterator must not be null");
         }
         if (predicate == null) {
             throw new NullPointerException("Predicate must not be null");
         }
-        return new FilterIterator(iterator, predicate);
+        return new FilterIterator<E>(iterator, predicate);
     }
-    
+
     /**
      * Gets a list iterator that filters another list iterator.
      * <p>
@@ -657,16 +662,16 @@
      * @return a new filtered iterator
      * @throws NullPointerException if either parameter is null
      */
-    public static ListIterator filteredListIterator(ListIterator listIterator, Predicate
predicate) {
+    public static <E> ListIterator<E> filteredListIterator(ListIterator<?
extends E> listIterator, Predicate<? super E> predicate) {
         if (listIterator == null) {
             throw new NullPointerException("ListIterator must not be null");
         }
         if (predicate == null) {
             throw new NullPointerException("Predicate must not be null");
         }
-        return new FilterListIterator(listIterator, predicate);
+        return new FilterListIterator<E>(listIterator, predicate);
     }
-    
+
     // Looping
     //-----------------------------------------------------------------------
     /**
@@ -680,13 +685,13 @@
      * @return a new looping iterator
      * @throws NullPointerException if the collection is null
      */
-    public static ResettableIterator loopingIterator(Collection coll) {
+    public static <E> ResettableIterator<E> loopingIterator(Collection<? extends
E> coll) {
         if (coll == null) {
             throw new NullPointerException("Collection must not be null");
         }
-        return new LoopingIterator(coll);
+        return new LoopingIterator<E>(coll);
     }
-    
+
     /**
      * Gets an iterator that loops continuously over the supplied list.
      * <p>
@@ -698,13 +703,13 @@
      * @throws NullPointerException if the list is null
      * @since Commons Collections 3.2
      */
-    public static ResettableListIterator loopingListIterator(List list) {
+    public static <E> ResettableListIterator<E> loopingListIterator(List<E>
list) {
         if (list == null) {
             throw new NullPointerException("List must not be null");
         }
-        return new LoopingListIterator(list);
+        return new LoopingListIterator<E>(list);
     }
-    
+
     // Views
     //-----------------------------------------------------------------------
     /**
@@ -713,31 +718,31 @@
      * @param enumeration  the enumeration to use
      * @return a new iterator
      */
-    public static Iterator asIterator(Enumeration enumeration) {
+    public static <E> Iterator<E> asIterator(Enumeration<? extends E> enumeration)
{
         if (enumeration == null) {
             throw new NullPointerException("Enumeration must not be null");
         }
-        return new EnumerationIterator(enumeration);
+        return new EnumerationIterator<E>(enumeration);
     }
 
     /**
-     * Gets an iterator that provides an iterator view of the given enumeration 
+     * Gets an iterator that provides an iterator view of the given enumeration
      * that will remove elements from the specified collection.
      *
      * @param enumeration  the enumeration to use
      * @param removeCollection  the collection to remove elements from
      * @return a new iterator
      */
-    public static Iterator asIterator(Enumeration enumeration, Collection removeCollection)
{
+    public static <E> Iterator<E> asIterator(Enumeration<? extends E> enumeration,
Collection<? super E> removeCollection) {
         if (enumeration == null) {
             throw new NullPointerException("Enumeration must not be null");
         }
         if (removeCollection == null) {
             throw new NullPointerException("Collection must not be null");
         }
-        return new EnumerationIterator(enumeration, removeCollection);
+        return new EnumerationIterator<E>(enumeration, removeCollection);
     }
-    
+
     /**
      * Gets an enumeration that wraps an iterator.
      *
@@ -745,13 +750,13 @@
      * @return a new enumeration
      * @throws NullPointerException if iterator is null
      */
-    public static Enumeration asEnumeration(Iterator iterator) {
+    public static <E> Enumeration<E> asEnumeration(Iterator<? extends E>
iterator) {
         if (iterator == null) {
             throw new NullPointerException("Iterator must not be null");
         }
-        return new IteratorEnumeration(iterator);
+        return new IteratorEnumeration<E>(iterator);
     }
-    
+
     /**
      * Gets a list iterator based on a simple iterator.
      * <p>
@@ -762,13 +767,13 @@
      * @return a new iterator
      * @throws NullPointerException if iterator parameter is null
      */
-    public static ListIterator toListIterator(Iterator iterator) {
+    public static <E> ListIterator<E> toListIterator(Iterator<? extends E>
iterator) {
         if (iterator == null) {
             throw new NullPointerException("Iterator must not be null");
         }
-        return new ListIteratorWrapper(iterator);
+        return new ListIteratorWrapper<E>(iterator);
     }
-    
+
     /**
      * Gets an array based on an iterator.
      * <p>
@@ -779,14 +784,14 @@
      * @return an array of the iterator contents
      * @throws NullPointerException if iterator parameter is null
      */
-    public static Object[] toArray(Iterator iterator) {
+    public static Object[] toArray(Iterator<?> iterator) {
         if (iterator == null) {
             throw new NullPointerException("Iterator must not be null");
         }
-        List list = toList(iterator, 100);
+        List<?> list = toList(iterator, 100);
         return list.toArray();
     }
-    
+
     /**
      * Gets an array based on an iterator.
      * <p>
@@ -800,17 +805,18 @@
      * @throws NullPointerException if arrayClass is null
      * @throws ClassCastException if the arrayClass is invalid
      */
-    public static Object[] toArray(Iterator iterator, Class arrayClass) {
+    @SuppressWarnings("unchecked")
+    public static <E> E[] toArray(Iterator<? extends E> iterator, Class<E>
arrayClass) {
         if (iterator == null) {
             throw new NullPointerException("Iterator must not be null");
         }
         if (arrayClass == null) {
             throw new NullPointerException("Array class must not be null");
         }
-        List list = toList(iterator, 100);
-        return list.toArray((Object[]) Array.newInstance(arrayClass, list.size()));
+        List<E> list = toList(iterator, 100);
+        return list.toArray((E[]) Array.newInstance(arrayClass, list.size()));
     }
-    
+
     /**
      * Gets a list based on an iterator.
      * <p>
@@ -821,10 +827,10 @@
      * @return a list of the iterator contents
      * @throws NullPointerException if iterator parameter is null
      */
-    public static List toList(Iterator iterator) {
+    public static <E> List<E> toList(Iterator<? extends E> iterator) {
         return toList(iterator, 10);
     }
-    
+
     /**
      * Gets a list based on an iterator.
      * <p>
@@ -837,24 +843,24 @@
      * @throws NullPointerException if iterator parameter is null
      * @throws IllegalArgumentException if the size is less than 1
      */
-    public static List toList(Iterator iterator, int estimatedSize) {
+    public static <E> List<E> toList(Iterator<? extends E> iterator, int
estimatedSize) {
         if (iterator == null) {
             throw new NullPointerException("Iterator must not be null");
         }
         if (estimatedSize < 1) {
             throw new IllegalArgumentException("Estimated size must be greater than 0");
         }
-        List list = new ArrayList(estimatedSize);
+        List<E> list = new ArrayList<E>(estimatedSize);
         while (iterator.hasNext()) {
             list.add(iterator.next());
         }
         return list;
     }
-    
-    /** 
+
+    /**
      * Gets a suitable Iterator for the given object.
      * <p>
-     * This method can handles objects as follows
+     * This method can handle objects as follows
      * <ul>
      * <li>null - empty iterator
      * <li>Iterator - returned directly
@@ -866,49 +872,47 @@
      * <li>object with iterator() public method accessed by reflection
      * <li>object - singleton iterator
      * </ul>
-     * 
+     *
      * @param obj  the object to convert to an iterator
      * @return a suitable iterator, never null
      */
-    public static Iterator getIterator(Object obj) {
+    @SuppressWarnings("unchecked")
+    public static Iterator<?> getIterator(Object obj) {
         if (obj == null) {
             return emptyIterator();
-            
-        } else if (obj instanceof Iterator) {
+        }
+        if (obj instanceof Iterator) {
             return (Iterator) obj;
-            
-        } else if (obj instanceof Collection) {
+        }
+        if (obj instanceof Collection) {
             return ((Collection) obj).iterator();
-            
-        } else if (obj instanceof Object[]) {
+        }
+        if (obj instanceof Object[]) {
             return new ObjectArrayIterator((Object[]) obj);
-            
-        } else if (obj instanceof Enumeration) {
+        }
+        if (obj instanceof Enumeration) {
             return new EnumerationIterator((Enumeration) obj);
-            
-        } else if (obj instanceof Map) {
+        }
+        if (obj instanceof Map) {
             return ((Map) obj).values().iterator();
-            
-        } else if (obj instanceof Dictionary) {
+        }
+        if (obj instanceof Dictionary) {
             return new EnumerationIterator(((Dictionary) obj).elements());
-            
         } else if (obj.getClass().isArray()) {
             return new ArrayIterator(obj);
-            
-        } else {
-            try {
-                Method method = obj.getClass().getMethod("iterator", (Class[]) null);
-                if (Iterator.class.isAssignableFrom(method.getReturnType())) {
-                    Iterator it = (Iterator) method.invoke(obj, (Object[]) null);
-                    if (it != null) {
-                        return it;
-                    }
+        }
+        try {
+            Method method = obj.getClass().getMethod("iterator", (Class[]) null);
+            if (Iterator.class.isAssignableFrom(method.getReturnType())) {
+                Iterator it = (Iterator) method.invoke(obj, (Object[]) null);
+                if (it != null) {
+                    return it;
                 }
-            } catch (Exception ex) {
-                // ignore
             }
-            return singletonIterator(obj);
+        } catch (Exception ex) {
+            // ignore
         }
+        return singletonIterator(obj);
     }
 
 }



Mime
View raw message