http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/functors/SwitchTransformer.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/functors/SwitchTransformer.java b/src/java/org/apache/commons/collections/functors/SwitchTransformer.java index 370a610..3e62247 100644 --- a/src/java/org/apache/commons/collections/functors/SwitchTransformer.java +++ b/src/java/org/apache/commons/collections/functors/SwitchTransformer.java @@ -17,7 +17,6 @@ package org.apache.commons.collections.functors; import java.io.Serializable; -import java.util.Iterator; import java.util.Map; import org.apache.commons.collections.Predicate; @@ -32,17 +31,17 @@ import org.apache.commons.collections.Transformer; * * @author Stephen Colebourne */ -public class SwitchTransformer implements Transformer, Serializable { +public class SwitchTransformer<I, O> implements Transformer<I, O>, Serializable { /** Serial version UID */ private static final long serialVersionUID = -6404460890903469332L; /** The tests to consider */ - private final Predicate[] iPredicates; + private final Predicate<? super I>[] iPredicates; /** The matching transformers to call */ - private final Transformer[] iTransformers; + private final Transformer<? super I, ? extends O>[] iTransformers; /** The default transformer to call if no tests match */ - private final Transformer iDefault; + private final Transformer<? super I, ? extends O> iDefault; /** * Factory method that performs validation and copies the parameter arrays. @@ -54,18 +53,21 @@ public class SwitchTransformer implements Transformer, Serializable { * @throws IllegalArgumentException if array is null * @throws IllegalArgumentException if any element in the array is null */ - public static Transformer getInstance(Predicate[] predicates, Transformer[] transformers, Transformer defaultTransformer) { + @SuppressWarnings("unchecked") + public static <I, O> Transformer<I, O> getInstance(Predicate<? super I>[] predicates, + Transformer<? super I, ? extends O>[] transformers, + Transformer<? super I, ? extends O> defaultTransformer) { FunctorUtils.validate(predicates); FunctorUtils.validate(transformers); if (predicates.length != transformers.length) { throw new IllegalArgumentException("The predicate and transformer arrays must be the same size"); } if (predicates.length == 0) { - return (defaultTransformer == null ? ConstantTransformer.NULL_INSTANCE : defaultTransformer); + return (Transformer<I, O>) (defaultTransformer == null ? ConstantTransformer.<I, O>getNullInstance() : defaultTransformer); } predicates = FunctorUtils.copy(predicates); transformers = FunctorUtils.copy(transformers); - return new SwitchTransformer(predicates, transformers, defaultTransformer); + return new SwitchTransformer<I, O>(predicates, transformers, defaultTransformer); } /** @@ -85,31 +87,30 @@ public class SwitchTransformer implements Transformer, Serializable { * @throws IllegalArgumentException if any transformer in the map is null * @throws ClassCastException if the map elements are of the wrong type */ - public static Transformer getInstance(Map predicatesAndTransformers) { - Transformer[] transformers = null; - Predicate[] preds = null; + @SuppressWarnings("unchecked") + public static <I, O> Transformer<I, O> getInstance( + Map<? extends Predicate<? super I>, ? extends Transformer<? super I, ? extends O>> predicatesAndTransformers) { if (predicatesAndTransformers == null) { throw new IllegalArgumentException("The predicate and transformer map must not be null"); } if (predicatesAndTransformers.size() == 0) { - return ConstantTransformer.NULL_INSTANCE; + return ConstantTransformer.<I, O>getNullInstance(); } // convert to array like this to guarantee iterator() ordering - Transformer defaultTransformer = (Transformer) predicatesAndTransformers.remove(null); + Transformer<? super I, ? extends O> defaultTransformer = predicatesAndTransformers.remove(null); int size = predicatesAndTransformers.size(); if (size == 0) { - return (defaultTransformer == null ? ConstantTransformer.NULL_INSTANCE : defaultTransformer); + return (Transformer<I, O>) (defaultTransformer == null ? ConstantTransformer.<I, O>getNullInstance() : defaultTransformer); } - transformers = new Transformer[size]; - preds = new Predicate[size]; + Transformer<? super I, ? extends O>[] transformers = new Transformer[size]; + Predicate<? super I>[] preds = new Predicate[size]; int i = 0; - for (Iterator it = predicatesAndTransformers.entrySet().iterator(); it.hasNext();) { - Map.Entry entry = (Map.Entry) it.next(); - preds[i] = (Predicate) entry.getKey(); - transformers[i] = (Transformer) entry.getValue(); + for (Map.Entry<? extends Predicate<? super I>, ? extends Transformer<? super I, ? extends O>> entry : predicatesAndTransformers.entrySet()) { + preds[i] = entry.getKey(); + transformers[i] = entry.getValue(); i++; } - return new SwitchTransformer(preds, transformers, defaultTransformer); + return new SwitchTransformer<I, O>(preds, transformers, defaultTransformer); } /** @@ -120,11 +121,14 @@ public class SwitchTransformer implements Transformer, Serializable { * @param transformers matching array of transformers, not cloned, no nulls * @param defaultTransformer the transformer to use if no match, null means return null */ - public SwitchTransformer(Predicate[] predicates, Transformer[] transformers, Transformer defaultTransformer) { + @SuppressWarnings("unchecked") + public SwitchTransformer(Predicate<? super I>[] predicates, + Transformer<? super I, ? extends O>[] transformers, + Transformer<? super I, ? extends O> defaultTransformer) { super(); iPredicates = predicates; iTransformers = transformers; - iDefault = (defaultTransformer == null ? ConstantTransformer.NULL_INSTANCE : defaultTransformer); + iDefault = (Transformer<? super I, ? extends O>) (defaultTransformer == null ? ConstantTransformer.<I, O>getNullInstance() : defaultTransformer); } /** @@ -134,7 +138,7 @@ public class SwitchTransformer implements Transformer, Serializable { * @param input the input object to transform * @return the transformed result */ - public Object transform(Object input) { + public O transform(I input) { for (int i = 0; i < iPredicates.length; i++) { if (iPredicates[i].evaluate(input) == true) { return iTransformers[i].transform(input); @@ -149,7 +153,7 @@ public class SwitchTransformer implements Transformer, Serializable { * @return the predicates * @since Commons Collections 3.1 */ - public Predicate[] getPredicates() { + public Predicate<? super I>[] getPredicates() { return iPredicates; } @@ -159,7 +163,7 @@ public class SwitchTransformer implements Transformer, Serializable { * @return the transformers * @since Commons Collections 3.1 */ - public Transformer[] getTransformers() { + public Transformer<? super I, ? extends O>[] getTransformers() { return iTransformers; } @@ -169,7 +173,7 @@ public class SwitchTransformer implements Transformer, Serializable { * @return the default transformer * @since Commons Collections 3.1 */ - public Transformer getDefaultTransformer() { + public Transformer<? super I, ? extends O> getDefaultTransformer() { return iDefault; }
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/functors/TransformedPredicate.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/functors/TransformedPredicate.java b/src/java/org/apache/commons/collections/functors/TransformedPredicate.java index 92c0447..5b5d3ed 100644 --- a/src/java/org/apache/commons/collections/functors/TransformedPredicate.java +++ b/src/java/org/apache/commons/collections/functors/TransformedPredicate.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. @@ -24,80 +24,82 @@ import org.apache.commons.collections.Transformer; /** * Predicate implementation that transforms the given object before invoking * another <code>Predicate</code>. - * + * * @since Commons Collections 3.1 * @version $Revision$ $Date$ * @author Alban Peignier * @author Stephen Colebourne */ -public final class TransformedPredicate implements Predicate, PredicateDecorator, Serializable { +public final class TransformedPredicate<T> implements Predicate<T>, PredicateDecorator<T>, Serializable { /** Serial version UID */ private static final long serialVersionUID = -5596090919668315834L; - + /** The transformer to call */ - private final Transformer iTransformer; + private final Transformer<? super T, ? extends T> iTransformer; + /** The predicate to call */ - private final Predicate iPredicate; + private final Predicate<? super T> iPredicate; /** * Factory to create the predicate. - * + * * @param transformer the transformer to call * @param predicate the predicate to call with the result of the transform * @return the predicate * @throws IllegalArgumentException if the transformer or the predicate is null */ - public static Predicate getInstance(Transformer transformer, Predicate predicate) { + public static <T> Predicate<T> getInstance(Transformer<? super T, ? extends T> transformer, Predicate<? super T> predicate) { if (transformer == null) { throw new IllegalArgumentException("The transformer to call must not be null"); } if (predicate == null) { throw new IllegalArgumentException("The predicate to call must not be null"); } - return new TransformedPredicate(transformer, predicate); + return new TransformedPredicate<T>(transformer, predicate); } /** * Constructor that performs no validation. * Use <code>getInstance</code> if you want that. - * + * * @param transformer the transformer to use * @param predicate the predicate to decorate */ - public TransformedPredicate(Transformer transformer, Predicate predicate) { + public TransformedPredicate(Transformer<? super T, ? extends T> transformer, Predicate<? super T> predicate) { iTransformer = transformer; iPredicate = predicate; } - + /** * Evaluates the predicate returning the result of the decorated predicate * once the input has been transformed - * + * * @param object the input object which will be transformed * @return true if decorated predicate returns true */ - public boolean evaluate(Object object) { - Object result = iTransformer.transform(object); + public boolean evaluate(T object) { + T result = iTransformer.transform(object); return iPredicate.evaluate(result); } /** * Gets the predicate being decorated. - * + * * @return the predicate as the only element in an array * @since Commons Collections 3.1 */ - public Predicate[] getPredicates() { + @SuppressWarnings("unchecked") + public Predicate<? super T>[] getPredicates() { return new Predicate[] {iPredicate}; } /** * Gets the transformer in use. - * + * * @return the transformer */ - public Transformer getTransformer() { + public Transformer<? super T, ? extends T> getTransformer() { return iTransformer; } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/functors/TransformerClosure.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/functors/TransformerClosure.java b/src/java/org/apache/commons/collections/functors/TransformerClosure.java index dc7110a..614b194 100644 --- a/src/java/org/apache/commons/collections/functors/TransformerClosure.java +++ b/src/java/org/apache/commons/collections/functors/TransformerClosure.java @@ -30,13 +30,13 @@ import org.apache.commons.collections.Transformer; * * @author Stephen Colebourne */ -public class TransformerClosure implements Closure, Serializable { +public class TransformerClosure<E> implements Closure<E>, Serializable { /** Serial version UID */ private static final long serialVersionUID = -5194992589193388969L; /** The transformer to wrap */ - private final Transformer iTransformer; + private final Transformer<? super E, ?> iTransformer; /** * Factory method that performs validation. @@ -46,11 +46,11 @@ public class TransformerClosure implements Closure, Serializable { * @param transformer the transformer to call, null means nop * @return the <code>transformer</code> closure */ - public static Closure getInstance(Transformer transformer) { + public static <E> Closure<E> getInstance(Transformer<? super E, ?> transformer) { if (transformer == null) { - return NOPClosure.INSTANCE; + return NOPClosure.<E>getInstance(); } - return new TransformerClosure(transformer); + return new TransformerClosure<E>(transformer); } /** @@ -59,7 +59,7 @@ public class TransformerClosure implements Closure, Serializable { * * @param transformer the transformer to call, not null */ - public TransformerClosure(Transformer transformer) { + public TransformerClosure(Transformer<? super E, ?> transformer) { super(); iTransformer = transformer; } @@ -69,7 +69,7 @@ public class TransformerClosure implements Closure, Serializable { * * @param input the input object */ - public void execute(Object input) { + public void execute(E input) { iTransformer.transform(input); } @@ -79,7 +79,7 @@ public class TransformerClosure implements Closure, Serializable { * @return the transformer * @since Commons Collections 3.1 */ - public Transformer getTransformer() { + public Transformer<? super E, ?> getTransformer() { return iTransformer; } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/functors/TransformerPredicate.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/functors/TransformerPredicate.java b/src/java/org/apache/commons/collections/functors/TransformerPredicate.java index 97483c8..396ed42 100644 --- a/src/java/org/apache/commons/collections/functors/TransformerPredicate.java +++ b/src/java/org/apache/commons/collections/functors/TransformerPredicate.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. @@ -24,69 +24,68 @@ import org.apache.commons.collections.Transformer; /** * Predicate implementation that returns the result of a transformer. - * + * * @since Commons Collections 3.0 * @version $Revision$ $Date$ * * @author Stephen Colebourne */ -public final class TransformerPredicate implements Predicate, Serializable { +public final class TransformerPredicate<T> implements Predicate<T>, Serializable { /** Serial version UID */ private static final long serialVersionUID = -2407966402920578741L; - + /** The transformer to call */ - private final Transformer iTransformer; - + private final Transformer<? super T, Boolean> iTransformer; + /** * Factory to create the predicate. - * + * * @param transformer the transformer to decorate * @return the predicate * @throws IllegalArgumentException if the transformer is null */ - public static Predicate getInstance(Transformer transformer) { + public static <T> Predicate<T> getInstance(Transformer<? super T, Boolean> transformer) { if (transformer == null) { throw new IllegalArgumentException("The transformer to call must not be null"); } - return new TransformerPredicate(transformer); + return new TransformerPredicate<T>(transformer); } /** * Constructor that performs no validation. * Use <code>getInstance</code> if you want that. - * + * * @param transformer the transformer to decorate */ - public TransformerPredicate(Transformer transformer) { + public TransformerPredicate(Transformer<? super T, Boolean> transformer) { super(); iTransformer = transformer; } /** * Evaluates the predicate returning the result of the decorated transformer. - * + * * @param object the input object * @return true if decorated transformer returns Boolean.TRUE * @throws FunctorException if the transformer returns an invalid type */ - public boolean evaluate(Object object) { - Object result = iTransformer.transform(object); - if (result instanceof Boolean == false) { + public boolean evaluate(T object) { + Boolean result = iTransformer.transform(object); + if (result == null) { throw new FunctorException( - "Transformer must return an instanceof Boolean, it was a " - + (result == null ? "null object" : result.getClass().getName())); + "Transformer must return an instanceof Boolean, it was a null object"); } - return ((Boolean) result).booleanValue(); + return result; } /** * Gets the transformer. - * + * * @return the transformer * @since Commons Collections 3.1 */ - public Transformer getTransformer() { + public Transformer<? super T, Boolean> getTransformer() { return iTransformer; } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/functors/UniquePredicate.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/functors/UniquePredicate.java b/src/java/org/apache/commons/collections/functors/UniquePredicate.java index ada31e6..22f189f 100644 --- a/src/java/org/apache/commons/collections/functors/UniquePredicate.java +++ b/src/java/org/apache/commons/collections/functors/UniquePredicate.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. @@ -25,28 +25,28 @@ import org.apache.commons.collections.Predicate; /** * Predicate implementation that returns true the first time an object is * passed into the predicate. - * + * * @since Commons Collections 3.0 * @version $Revision$ $Date$ * * @author Stephen Colebourne */ -public final class UniquePredicate implements Predicate, Serializable { +public final class UniquePredicate<T> implements Predicate<T>, Serializable { /** Serial version UID */ private static final long serialVersionUID = -3319417438027438040L; - + /** The set of previously seen objects */ - private final Set iSet = new HashSet(); - + private final Set<T> iSet = new HashSet<T>(); + /** * Factory to create the predicate. - * + * * @return the predicate * @throws IllegalArgumentException if the predicate is null */ - public static Predicate getInstance() { - return new UniquePredicate(); + public static <E> Predicate<E> getInstance() { + return new UniquePredicate<E>(); } /** @@ -60,11 +60,11 @@ public final class UniquePredicate implements Predicate, Serializable { /** * Evaluates the predicate returning true if the input object hasn't been * received yet. - * + * * @param object the input object * @return true if this is the first time the object is seen */ - public boolean evaluate(Object object) { + public boolean evaluate(T object) { return iSet.add(object); } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/functors/WhileClosure.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/functors/WhileClosure.java b/src/java/org/apache/commons/collections/functors/WhileClosure.java index 90957c6..9970809 100644 --- a/src/java/org/apache/commons/collections/functors/WhileClosure.java +++ b/src/java/org/apache/commons/collections/functors/WhileClosure.java @@ -30,15 +30,15 @@ import org.apache.commons.collections.Predicate; * * @author Stephen Colebourne */ -public class WhileClosure implements Closure, Serializable { +public class WhileClosure<E> implements Closure<E>, Serializable { /** Serial version UID */ private static final long serialVersionUID = -3110538116913760108L; /** The test condition */ - private final Predicate iPredicate; + private final Predicate<? super E> iPredicate; /** The closure to call */ - private final Closure iClosure; + private final Closure<? super E> iClosure; /** The flag, true is a do loop, false is a while */ private final boolean iDoLoop; @@ -51,14 +51,14 @@ public class WhileClosure implements Closure, Serializable { * @return the <code>while</code> closure * @throws IllegalArgumentException if the predicate or closure is null */ - public static Closure getInstance(Predicate predicate, Closure closure, boolean doLoop) { + public static <E> Closure<E> getInstance(Predicate<? super E> predicate, Closure<? super E> closure, boolean doLoop) { if (predicate == null) { throw new IllegalArgumentException("Predicate must not be null"); } if (closure == null) { throw new IllegalArgumentException("Closure must not be null"); } - return new WhileClosure(predicate, closure, doLoop); + return new WhileClosure<E>(predicate, closure, doLoop); } /** @@ -69,7 +69,7 @@ public class WhileClosure implements Closure, Serializable { * @param closure the closure the execute, not null * @param doLoop true to act as a do-while loop, always executing the closure once */ - public WhileClosure(Predicate predicate, Closure closure, boolean doLoop) { + public WhileClosure(Predicate<? super E> predicate, Closure<? super E> closure, boolean doLoop) { super(); iPredicate = predicate; iClosure = closure; @@ -81,7 +81,7 @@ public class WhileClosure implements Closure, Serializable { * * @param input the input object */ - public void execute(Object input) { + public void execute(E input) { if (iDoLoop) { iClosure.execute(input); } @@ -96,7 +96,7 @@ public class WhileClosure implements Closure, Serializable { * @return the predicate * @since Commons Collections 3.1 */ - public Predicate getPredicate() { + public Predicate<? super E> getPredicate() { return iPredicate; } @@ -106,7 +106,7 @@ public class WhileClosure implements Closure, Serializable { * @return the closure * @since Commons Collections 3.1 */ - public Closure getClosure() { + public Closure<? super E> getClosure() { return iClosure; } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/AbstractEmptyIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/AbstractEmptyIterator.java b/src/java/org/apache/commons/collections/iterators/AbstractEmptyIterator.java index 93e4cfd..4546ddf 100644 --- a/src/java/org/apache/commons/collections/iterators/AbstractEmptyIterator.java +++ b/src/java/org/apache/commons/collections/iterators/AbstractEmptyIterator.java @@ -26,7 +26,7 @@ import java.util.NoSuchElementException; * * @author Stephen Colebourne */ -abstract class AbstractEmptyIterator { +abstract class AbstractEmptyIterator<E> { /** * Constructor. @@ -39,7 +39,7 @@ abstract class AbstractEmptyIterator { return false; } - public Object next() { + public E next() { throw new NoSuchElementException("Iterator contains no elements"); } @@ -47,7 +47,7 @@ abstract class AbstractEmptyIterator { return false; } - public Object previous() { + public E previous() { throw new NoSuchElementException("Iterator contains no elements"); } @@ -59,11 +59,11 @@ abstract class AbstractEmptyIterator { return -1; } - public void add(Object obj) { + public void add(E obj) { throw new UnsupportedOperationException("add() not supported for empty Iterator"); } - public void set(Object obj) { + public void set(E obj) { throw new IllegalStateException("Iterator contains no elements"); } @@ -71,18 +71,6 @@ abstract class AbstractEmptyIterator { throw new IllegalStateException("Iterator contains no elements"); } - public Object getKey() { - throw new IllegalStateException("Iterator contains no elements"); - } - - public Object getValue() { - throw new IllegalStateException("Iterator contains no elements"); - } - - public Object setValue(Object value) { - throw new IllegalStateException("Iterator contains no elements"); - } - public void reset() { // do nothing } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/AbstractEmptyMapIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/AbstractEmptyMapIterator.java b/src/java/org/apache/commons/collections/iterators/AbstractEmptyMapIterator.java new file mode 100644 index 0000000..d59684b --- /dev/null +++ b/src/java/org/apache/commons/collections/iterators/AbstractEmptyMapIterator.java @@ -0,0 +1,50 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.collections.iterators; + +/** + * Provides an implementation of an empty map iterator. + * + * @since Commons Collections 5 + * @version $Revision$ $Date$ + * + * @author Stephen Colebourne + * @author Matt Benson + */ +public abstract class AbstractEmptyMapIterator<K, V> extends AbstractEmptyIterator<K> { + + /** + * Create a new AbstractEmptyMapIterator. + */ + public AbstractEmptyMapIterator() { + super(); + } + + public K getKey() { + throw new IllegalStateException("Iterator contains no elements"); + } + + public V getValue() { + throw new IllegalStateException("Iterator contains no elements"); + } + + public V setValue(V value) { + throw new IllegalStateException("Iterator contains no elements"); + } + + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/AbstractIteratorDecorator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/AbstractIteratorDecorator.java b/src/java/org/apache/commons/collections/iterators/AbstractIteratorDecorator.java index 0dce364..2151ebc 100644 --- a/src/java/org/apache/commons/collections/iterators/AbstractIteratorDecorator.java +++ b/src/java/org/apache/commons/collections/iterators/AbstractIteratorDecorator.java @@ -18,7 +18,7 @@ package org.apache.commons.collections.iterators; import java.util.Iterator; -/** +/** * Provides basic behaviour for decorating an iterator with extra functionality. * <p> * All methods are forwarded to the decorated iterator. @@ -29,10 +29,7 @@ import java.util.Iterator; * @author James Strachan * @author Stephen Colebourne */ -public class AbstractIteratorDecorator implements Iterator { - - /** The iterator being decorated */ - protected final Iterator iterator; +public abstract class AbstractIteratorDecorator<E> extends AbstractUntypedIteratorDecorator<E, E> { //----------------------------------------------------------------------- /** @@ -41,34 +38,12 @@ public class AbstractIteratorDecorator implements Iterator { * @param iterator the iterator to decorate, must not be null * @throws IllegalArgumentException if the collection is null */ - public AbstractIteratorDecorator(Iterator iterator) { - super(); - if (iterator == null) { - throw new IllegalArgumentException("Iterator must not be null"); - } - this.iterator = iterator; - } - - /** - * Gets the iterator being decorated. - * - * @return the decorated iterator - */ - protected Iterator getIterator() { - return iterator; - } - - //----------------------------------------------------------------------- - public boolean hasNext() { - return iterator.hasNext(); - } - - public Object next() { - return iterator.next(); + protected AbstractIteratorDecorator(Iterator<E> iterator) { + super(iterator); } - public void remove() { - iterator.remove(); + public E next() { + return getIterator().next(); } } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/AbstractMapIteratorDecorator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/AbstractMapIteratorDecorator.java b/src/java/org/apache/commons/collections/iterators/AbstractMapIteratorDecorator.java index 0db387f..f728680 100644 --- a/src/java/org/apache/commons/collections/iterators/AbstractMapIteratorDecorator.java +++ b/src/java/org/apache/commons/collections/iterators/AbstractMapIteratorDecorator.java @@ -28,10 +28,10 @@ import org.apache.commons.collections.MapIterator; * * @author Stephen Colebourne */ -public class AbstractMapIteratorDecorator implements MapIterator { +public class AbstractMapIteratorDecorator<K, V> implements MapIterator<K, V> { /** The iterator being decorated */ - protected final MapIterator iterator; + protected final MapIterator<K, V> iterator; //----------------------------------------------------------------------- /** @@ -40,7 +40,7 @@ public class AbstractMapIteratorDecorator implements MapIterator { * @param iterator the iterator to decorate, must not be null * @throws IllegalArgumentException if the collection is null */ - public AbstractMapIteratorDecorator(MapIterator iterator) { + public AbstractMapIteratorDecorator(MapIterator<K, V> iterator) { super(); if (iterator == null) { throw new IllegalArgumentException("MapIterator must not be null"); @@ -53,7 +53,7 @@ public class AbstractMapIteratorDecorator implements MapIterator { * * @return the decorated iterator */ - protected MapIterator getMapIterator() { + protected MapIterator<K, V> getMapIterator() { return iterator; } @@ -62,7 +62,7 @@ public class AbstractMapIteratorDecorator implements MapIterator { return iterator.hasNext(); } - public Object next() { + public K next() { return iterator.next(); } @@ -70,15 +70,15 @@ public class AbstractMapIteratorDecorator implements MapIterator { iterator.remove(); } - public Object getKey() { + public K getKey() { return iterator.getKey(); } - public Object getValue() { + public V getValue() { return iterator.getValue(); } - public Object setValue(Object obj) { + public V setValue(V obj) { return iterator.setValue(obj); } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/AbstractOrderedMapIteratorDecorator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/AbstractOrderedMapIteratorDecorator.java b/src/java/org/apache/commons/collections/iterators/AbstractOrderedMapIteratorDecorator.java index 9dd866e..8f1d687 100644 --- a/src/java/org/apache/commons/collections/iterators/AbstractOrderedMapIteratorDecorator.java +++ b/src/java/org/apache/commons/collections/iterators/AbstractOrderedMapIteratorDecorator.java @@ -28,10 +28,10 @@ import org.apache.commons.collections.OrderedMapIterator; * * @author Stephen Colebourne */ -public class AbstractOrderedMapIteratorDecorator implements OrderedMapIterator { +public class AbstractOrderedMapIteratorDecorator<K, V> implements OrderedMapIterator<K, V> { /** The iterator being decorated */ - protected final OrderedMapIterator iterator; + protected final OrderedMapIterator<K, V> iterator; //----------------------------------------------------------------------- /** @@ -40,7 +40,7 @@ public class AbstractOrderedMapIteratorDecorator implements OrderedMapIterator { * @param iterator the iterator to decorate, must not be null * @throws IllegalArgumentException if the collection is null */ - public AbstractOrderedMapIteratorDecorator(OrderedMapIterator iterator) { + public AbstractOrderedMapIteratorDecorator(OrderedMapIterator<K, V> iterator) { super(); if (iterator == null) { throw new IllegalArgumentException("OrderedMapIterator must not be null"); @@ -53,7 +53,7 @@ public class AbstractOrderedMapIteratorDecorator implements OrderedMapIterator { * * @return the decorated iterator */ - protected OrderedMapIterator getOrderedMapIterator() { + protected OrderedMapIterator<K, V> getOrderedMapIterator() { return iterator; } @@ -62,7 +62,7 @@ public class AbstractOrderedMapIteratorDecorator implements OrderedMapIterator { return iterator.hasNext(); } - public Object next() { + public K next() { return iterator.next(); } @@ -70,7 +70,7 @@ public class AbstractOrderedMapIteratorDecorator implements OrderedMapIterator { return iterator.hasPrevious(); } - public Object previous() { + public K previous() { return iterator.previous(); } @@ -78,15 +78,15 @@ public class AbstractOrderedMapIteratorDecorator implements OrderedMapIterator { iterator.remove(); } - public Object getKey() { + public K getKey() { return iterator.getKey(); } - public Object getValue() { + public V getValue() { return iterator.getValue(); } - public Object setValue(Object obj) { + public V setValue(V obj) { return iterator.setValue(obj); } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/AbstractUntypedIteratorDecorator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/AbstractUntypedIteratorDecorator.java b/src/java/org/apache/commons/collections/iterators/AbstractUntypedIteratorDecorator.java new file mode 100644 index 0000000..57ba89f --- /dev/null +++ b/src/java/org/apache/commons/collections/iterators/AbstractUntypedIteratorDecorator.java @@ -0,0 +1,54 @@ +/** + * + */ +package org.apache.commons.collections.iterators; + +import java.util.Iterator; + +/** + * Provides basic behaviour for decorating an iterator with extra functionality + * without committing the generic type of the Iterator implementation. + * <p> + * All methods are forwarded to the decorated iterator. + * + * @since Commons Collections 5 + * @version $Revision$ $Date$ + * + * @author James Strachan + * @author Stephen Colebourne + * @author Matt Benson + */ +public abstract class AbstractUntypedIteratorDecorator<I, O> implements Iterator<O> { + + /** The iterator being decorated */ + protected final Iterator<I> iterator; + + /** + * Create a new AbstractUntypedIteratorDecorator. + */ + protected AbstractUntypedIteratorDecorator(Iterator<I> iterator) { + super(); + if (iterator == null) { + throw new IllegalArgumentException("Iterator must not be null"); + } + this.iterator = iterator; + } + + /** + * Gets the iterator being decorated. + * + * @return the decorated iterator + */ + protected Iterator<I> getIterator() { + return iterator; + } + + public boolean hasNext() { + return iterator.hasNext(); + } + + public void remove() { + iterator.remove(); + } + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/ArrayIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/ArrayIterator.java b/src/java/org/apache/commons/collections/iterators/ArrayIterator.java index bd96825..809101c 100644 --- a/src/java/org/apache/commons/collections/iterators/ArrayIterator.java +++ b/src/java/org/apache/commons/collections/iterators/ArrayIterator.java @@ -41,7 +41,7 @@ import org.apache.commons.collections.ResettableIterator; * @author Neil O'Toole * @author Stephen Colebourne */ -public class ArrayIterator implements ResettableIterator { +public class ArrayIterator<E> implements ResettableIterator<E> { /** The array to iterate over */ protected Object array; @@ -159,11 +159,12 @@ public class ArrayIterator implements ResettableIterator { * @throws NoSuchElementException if all the elements in the array * have already been returned */ - public Object next() { + @SuppressWarnings("unchecked") + public E next() { if (hasNext() == false) { throw new NoSuchElementException(); } - return Array.get(array, index++); + return (E) Array.get(array, index++); } /** http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/ArrayListIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/ArrayListIterator.java b/src/java/org/apache/commons/collections/iterators/ArrayListIterator.java index bd0ef55..159bcc2 100644 --- a/src/java/org/apache/commons/collections/iterators/ArrayListIterator.java +++ b/src/java/org/apache/commons/collections/iterators/ArrayListIterator.java @@ -44,8 +44,8 @@ import org.apache.commons.collections.ResettableListIterator; * @author Stephen Colebourne * @author Phil Steitz */ -public class ArrayListIterator extends ArrayIterator - implements ListIterator, ResettableListIterator { +public class ArrayListIterator<E> extends ArrayIterator<E> + implements ListIterator<E>, ResettableListIterator<E> { /** * Holds the index of the last item returned by a call to <code>next()</code> @@ -129,12 +129,13 @@ public class ArrayListIterator extends ArrayIterator * @return the previous element * @throws NoSuchElementException if there is no previous element */ - public Object previous() { + @SuppressWarnings("unchecked") + public E previous() { if (hasPrevious() == false) { throw new NoSuchElementException(); } this.lastItemIndex = --this.index; - return Array.get(this.array, this.index); + return (E) Array.get(this.array, this.index); } /** @@ -143,12 +144,13 @@ public class ArrayListIterator extends ArrayIterator * @return the next element * @throws NoSuchElementException if there is no next element */ - public Object next() { + @SuppressWarnings("unchecked") + public E next() { if (hasNext() == false) { throw new NoSuchElementException(); } this.lastItemIndex = this.index; - return Array.get(this.array, this.index++); + return (E) Array.get(this.array, this.index++); } /** http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/CollatingIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/CollatingIterator.java b/src/java/org/apache/commons/collections/iterators/CollatingIterator.java index e50907c..9105e9e 100644 --- a/src/java/org/apache/commons/collections/iterators/CollatingIterator.java +++ b/src/java/org/apache/commons/collections/iterators/CollatingIterator.java @@ -27,99 +27,107 @@ import java.util.NoSuchElementException; import org.apache.commons.collections.list.UnmodifiableList; /** - * Provides an ordered iteration over the elements contained in - * a collection of ordered Iterators. + * Provides an ordered iteration over the elements contained in a collection of + * ordered Iterators. * <p> - * Given two ordered {@link Iterator} instances <code>A</code> and <code>B</code>, - * the {@link #next} method on this iterator will return the lesser of - * <code>A.next()</code> and <code>B.next()</code>. - * + * Given two ordered {@link Iterator} instances <code>A</code> and + * <code>B</code>, the {@link #next} method on this iterator will return the + * lesser of <code>A.next()</code> and <code>B.next()</code>. + * * @since Commons Collections 2.1 - * @version $Revision$ $Date$ + * @version $Revision$ $Date: 2006-10-27 19:52:37 -0500 (Fri, 27 Oct + * 2006) $ * * @author Rodney Waldhoff * @author Stephen Colebourne */ -public class CollatingIterator implements Iterator { +public class CollatingIterator<E> implements Iterator<E> { /** The {@link Comparator} used to evaluate order. */ - private Comparator comparator = null; + private Comparator<? super E> comparator = null; /** The list of {@link Iterator}s to evaluate. */ - private ArrayList iterators = null; - + private ArrayList<Iterator<? extends E>> iterators = null; + /** {@link Iterator#next Next} objects peeked from each iterator. */ - private ArrayList values = null; - + private ArrayList<E> values = null; + /** Whether or not each {@link #values} element has been set. */ private BitSet valueSet = null; - /** Index of the {@link #iterators iterator} from whom the last returned value was obtained. */ + /** + * Index of the {@link #iterators iterator} from whom the last returned + * value was obtained. + */ private int lastReturned = -1; // Constructors // ---------------------------------------------------------------------- /** - * Constructs a new <code>CollatingIterator</code>. Natural sort order - * will be used, and child iterators will have to be manually added - * using the {@link #addIterator(Iterator)} method. + * Constructs a new <code>CollatingIterator</code>. Natural sort order will + * be used, and child iterators will have to be manually added using the + * {@link #addIterator(Iterator)} method. */ public CollatingIterator() { - this(null,2); + this(null, 2); } - + /** * Constructs a new <code>CollatingIterator</code> that will used the - * specified comparator for ordering. Child iterators will have to be + * specified comparator for ordering. Child iterators will have to be * manually added using the {@link #addIterator(Iterator)} method. - * - * @param comp the comparator to use to sort, or null to use natural sort order + * + * @param comp the comparator to use to sort, or null to use natural sort + * order */ - public CollatingIterator(final Comparator comp) { - this(comp,2); + public CollatingIterator(final Comparator<? super E> comp) { + this(comp, 2); } - + /** * Constructs a new <code>CollatingIterator</code> that will used the * specified comparator for ordering and have the specified initial - * capacity. Child iterators will have to be - * manually added using the {@link #addIterator(Iterator)} method. - * - * @param comp the comparator to use to sort, or null to use natural sort order - * @param initIterCapacity the initial capacity for the internal list - * of child iterators + * capacity. Child iterators will have to be manually added using the + * {@link #addIterator(Iterator)} method. + * + * @param comp the comparator to use to sort, or null to use natural sort + * order + * @param initIterCapacity the initial capacity for the internal list of + * child iterators */ - public CollatingIterator(final Comparator comp, final int initIterCapacity) { - iterators = new ArrayList(initIterCapacity); + public CollatingIterator(final Comparator<? super E> comp, final int initIterCapacity) { + iterators = new ArrayList<Iterator<? extends E>>(initIterCapacity); setComparator(comp); } /** * Constructs a new <code>CollatingIterator</code> that will use the - * specified comparator to provide ordered iteration over the two - * given iterators. - * - * @param comp the comparator to use to sort, or null to use natural sort order - * @param a the first child ordered iterator - * @param b the second child ordered iterator + * specified comparator to provide ordered iteration over the two given + * iterators. + * + * @param comp the comparator to use to sort, or null to use natural sort + * order + * @param a the first child ordered iterator + * @param b the second child ordered iterator * @throws NullPointerException if either iterator is null */ - public CollatingIterator(final Comparator comp, final Iterator a, final Iterator b) { - this(comp,2); + public CollatingIterator(final Comparator<? super E> comp, final Iterator<? extends E> a, final Iterator<? extends E> b) { + this(comp, 2); addIterator(a); addIterator(b); } /** * Constructs a new <code>CollatingIterator</code> that will use the - * specified comparator to provide ordered iteration over the array - * of iterators. - * - * @param comp the comparator to use to sort, or null to use natural sort order - * @param iterators the array of iterators + * specified comparator to provide ordered iteration over the array of + * iterators. + * + * @param comp the comparator to use to sort, or null to use natural sort + * order + * @param iterators the array of iterators * @throws NullPointerException if iterators array is or contains null */ - public CollatingIterator(final Comparator comp, final Iterator[] iterators) { + public CollatingIterator(final Comparator<? super E> comp, final Iterator<? extends E>[] iterators) { this(comp, iterators.length); for (int i = 0; i < iterators.length; i++) { addIterator(iterators[i]); @@ -128,20 +136,21 @@ public class CollatingIterator implements Iterator { /** * Constructs a new <code>CollatingIterator</code> that will use the - * specified comparator to provide ordered iteration over the collection - * of iterators. - * - * @param comp the comparator to use to sort, or null to use natural sort order - * @param iterators the collection of iterators - * @throws NullPointerException if the iterators collection is or contains null + * specified comparator to provide ordered iteration over the collection of + * iterators. + * + * @param comp the comparator to use to sort, or null to use natural sort + * order + * @param iterators the collection of iterators + * @throws NullPointerException if the iterators collection is or contains + * null * @throws ClassCastException if the iterators collection contains an - * element that's not an {@link Iterator} + * element that's not an {@link Iterator} */ - public CollatingIterator(final Comparator comp, final Collection iterators) { + public CollatingIterator(final Comparator<? super E> comp, final Collection<Iterator<? extends E>> iterators) { this(comp, iterators.size()); - for (Iterator it = iterators.iterator(); it.hasNext();) { - Iterator item = (Iterator) it.next(); - addIterator(item); + for (Iterator<? extends E> iterator : iterators) { + addIterator(iterator); } } @@ -150,11 +159,11 @@ public class CollatingIterator implements Iterator { /** * Adds the given {@link Iterator} to the iterators being collated. * - * @param iterator the iterator to add to the collation, must not be null + * @param iterator the iterator to add to the collation, must not be null * @throws IllegalStateException if iteration has started * @throws NullPointerException if the iterator is null */ - public void addIterator(final Iterator iterator) { + public void addIterator(final Iterator<? extends E> iterator) { checkNotStarted(); if (iterator == null) { throw new NullPointerException("Iterator must not be null"); @@ -165,13 +174,13 @@ public class CollatingIterator implements Iterator { /** * Sets the iterator at the given index. * - * @param index index of the Iterator to replace - * @param iterator Iterator to place at the given index + * @param index index of the Iterator to replace + * @param iterator Iterator to place at the given index * @throws IndexOutOfBoundsException if index < 0 or index > size() * @throws IllegalStateException if iteration has started * @throws NullPointerException if the iterator is null */ - public void setIterator(final int index, final Iterator iterator) { + public void setIterator(final int index, final Iterator<? extends E> iterator) { checkNotStarted(); if (iterator == null) { throw new NullPointerException("Iterator must not be null"); @@ -184,14 +193,14 @@ public class CollatingIterator implements Iterator { * * @return the unmodifiable list of iterators added */ - public List getIterators() { + public List<Iterator<? extends E>> getIterators() { return UnmodifiableList.decorate(iterators); } /** * Gets the {@link Comparator} by which collatation occurs. */ - public Comparator getComparator() { + public Comparator<? super E> getComparator() { return comparator; } @@ -200,7 +209,7 @@ public class CollatingIterator implements Iterator { * * @throws IllegalStateException if iteration has started */ - public void setComparator(final Comparator comp) { + public void setComparator(final Comparator<? super E> comp) { checkNotStarted(); comparator = comp; } @@ -209,7 +218,7 @@ public class CollatingIterator implements Iterator { // ------------------------------------------------------------------- /** * Returns <code>true</code> if any child iterator has remaining elements. - * + * * @return true if this iterator has remaining elements */ public boolean hasNext() { @@ -219,48 +228,46 @@ public class CollatingIterator implements Iterator { /** * Returns the next ordered element from a child iterator. - * + * * @return the next ordered element * @throws NoSuchElementException if no child iterator has any more elements */ - public Object next() throws NoSuchElementException { + public E next() throws NoSuchElementException { if (hasNext() == false) { throw new NoSuchElementException(); } int leastIndex = least(); if (leastIndex == -1) { throw new NoSuchElementException(); - } else { - Object val = values.get(leastIndex); - clear(leastIndex); - lastReturned = leastIndex; - return val; } + E val = values.get(leastIndex); + clear(leastIndex); + lastReturned = leastIndex; + return val; } /** - * Removes the last returned element from the child iterator that - * produced it. - * - * @throws IllegalStateException if there is no last returned element, - * or if the last returned element has already been removed + * Removes the last returned element from the child iterator that produced + * it. + * + * @throws IllegalStateException if there is no last returned element, or if + * the last returned element has already been removed */ public void remove() { if (lastReturned == -1) { throw new IllegalStateException("No value can be removed at present"); } - Iterator it = (Iterator) (iterators.get(lastReturned)); - it.remove(); + iterators.get(lastReturned).remove(); } // Private Methods // ------------------------------------------------------------------- - /** + /** * Initializes the collating state if it hasn't been already. */ private void start() { if (values == null) { - values = new ArrayList(iterators.size()); + values = new ArrayList<E>(iterators.size()); valueSet = new BitSet(iterators.size()); for (int i = 0; i < iterators.size(); i++) { values.add(null); @@ -269,40 +276,38 @@ public class CollatingIterator implements Iterator { } } - /** - * Sets the {@link #values} and {@link #valueSet} attributes - * at position <i>i</i> to the next value of the - * {@link #iterators iterator} at position <i>i</i>, or - * clear them if the <i>i</i><sup>th</sup> iterator - * has no next value. - * + /** + * Sets the {@link #values} and {@link #valueSet} attributes at position + * <i>i</i> to the next value of the {@link #iterators iterator} at position + * <i>i</i>, or clear them if the <i>i</i><sup>th</sup> iterator has no next + * value. + * * @return <tt>false</tt> iff there was no value to set */ private boolean set(int i) { - Iterator it = (Iterator)(iterators.get(i)); + Iterator<? extends E> it = iterators.get(i); if (it.hasNext()) { values.set(i, it.next()); valueSet.set(i); return true; - } else { - values.set(i,null); - valueSet.clear(i); - return false; } + values.set(i, null); + valueSet.clear(i); + return false; } - /** - * Clears the {@link #values} and {@link #valueSet} attributes - * at position <i>i</i>. + /** + * Clears the {@link #values} and {@link #valueSet} attributes at position + * <i>i</i>. */ private void clear(int i) { - values.set(i,null); + values.set(i, null); valueSet.clear(i); } - /** - * Throws {@link IllegalStateException} if iteration has started - * via {@link #start}. + /** + * Throws {@link IllegalStateException} if iteration has started via + * {@link #start}. * * @throws IllegalStateException if iteration started */ @@ -312,7 +317,7 @@ public class CollatingIterator implements Iterator { } } - /** + /** * Returns the index of the least element in {@link #values}, * {@link #set(int) setting} any uninitialized values. * @@ -320,7 +325,7 @@ public class CollatingIterator implements Iterator { */ private int least() { int leastIndex = -1; - Object leastObject = null; + E leastObject = null; for (int i = 0; i < values.size(); i++) { if (valueSet.get(i) == false) { set(i); @@ -330,8 +335,8 @@ public class CollatingIterator implements Iterator { leastIndex = i; leastObject = values.get(i); } else { - Object curObject = values.get(i); - if (comparator.compare(curObject,leastObject) < 0) { + E curObject = values.get(i); + if (comparator.compare(curObject, leastObject) < 0) { leastObject = curObject; leastIndex = i; } @@ -342,7 +347,7 @@ public class CollatingIterator implements Iterator { } /** - * Returns <code>true</code> iff any bit in the given set is + * Returns <code>true</code> iff any bit in the given set is * <code>true</code>. */ private boolean anyValueSet(BitSet set) { @@ -355,13 +360,12 @@ public class CollatingIterator implements Iterator { } /** - * Returns <code>true</code> iff any {@link Iterator} - * in the given list has a next value. + * Returns <code>true</code> iff any {@link Iterator} in the given list has + * a next value. */ - private boolean anyHasNext(ArrayList iters) { - for (int i = 0; i < iters.size(); i++) { - Iterator it = (Iterator) iters.get(i); - if (it.hasNext()) { + private boolean anyHasNext(ArrayList<Iterator<? extends E>> iters) { + for (Iterator<? extends E> iterator : iters) { + if (iterator.hasNext()) { return true; } } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/EmptyIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/EmptyIterator.java b/src/java/org/apache/commons/collections/iterators/EmptyIterator.java index e82bc17..09614bd 100644 --- a/src/java/org/apache/commons/collections/iterators/EmptyIterator.java +++ b/src/java/org/apache/commons/collections/iterators/EmptyIterator.java @@ -32,18 +32,39 @@ import org.apache.commons.collections.ResettableIterator; * * @author Stephen Colebourne */ -public class EmptyIterator extends AbstractEmptyIterator implements ResettableIterator { +public class EmptyIterator<E> extends AbstractEmptyIterator<E> implements ResettableIterator<E> { /** * Singleton instance of the iterator. * @since Commons Collections 3.1 */ - public static final ResettableIterator RESETTABLE_INSTANCE = new EmptyIterator(); + public static final ResettableIterator<Object> RESETTABLE_INSTANCE = new EmptyIterator<Object>(); + /** * Singleton instance of the iterator. * @since Commons Collections 2.1.1 and 3.1 */ - public static final Iterator INSTANCE = RESETTABLE_INSTANCE; + public static final Iterator<Object> INSTANCE = RESETTABLE_INSTANCE; + + /** + * Get a typed resettable empty iterator instance. + * @param <E> + * @return ResettableIterator<E> + */ + @SuppressWarnings("unchecked") + public static <E> ResettableIterator<E> getResettableInstance() { + return (ResettableIterator<E>) RESETTABLE_INSTANCE; + } + + /** + * Get a typed empty iterator instance. + * @param <E> + * @return Iterator<E> + */ + @SuppressWarnings("unchecked") + public static <E> Iterator<E> getInstance() { + return (Iterator<E>) INSTANCE; + } /** * Constructor. http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/EmptyListIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/EmptyListIterator.java b/src/java/org/apache/commons/collections/iterators/EmptyListIterator.java index bb2e23a..4d702cb 100644 --- a/src/java/org/apache/commons/collections/iterators/EmptyListIterator.java +++ b/src/java/org/apache/commons/collections/iterators/EmptyListIterator.java @@ -20,30 +20,53 @@ import java.util.ListIterator; import org.apache.commons.collections.ResettableListIterator; -/** +/** * Provides an implementation of an empty list iterator. * <p> - * This class provides an implementation of an empty list iterator. - * This class provides for binary compatability between Commons Collections - * 2.1.1 and 3.1 due to issues with <code>IteratorUtils</code>. - * + * This class provides an implementation of an empty list iterator. This class + * provides for binary compatability between Commons Collections 2.1.1 and 3.1 + * due to issues with <code>IteratorUtils</code>. + * * @since Commons Collections 2.1.1 and 3.1 - * @version $Revision$ $Date$ + * @version $Revision$ $Date: 2006-10-27 19:52:37 -0500 (Fri, 27 Oct + * 2006) $ * * @author Stephen Colebourne */ -public class EmptyListIterator extends AbstractEmptyIterator implements ResettableListIterator { +public class EmptyListIterator<E> extends AbstractEmptyIterator<E> implements + ResettableListIterator<E> { /** * Singleton instance of the iterator. * @since Commons Collections 3.1 */ - public static final ResettableListIterator RESETTABLE_INSTANCE = new EmptyListIterator(); + public static final ResettableListIterator<Object> RESETTABLE_INSTANCE = new EmptyListIterator<Object>(); + /** * Singleton instance of the iterator. * @since Commons Collections 2.1.1 and 3.1 */ - public static final ListIterator INSTANCE = RESETTABLE_INSTANCE; + public static final ListIterator<Object> INSTANCE = RESETTABLE_INSTANCE; + + /** + * Get a typed instance of the iterator. + * @param <E> + * @return {@link ResettableListIterator}<E> + */ + @SuppressWarnings("unchecked") + public static <E> ResettableListIterator<E> getResettableInstance() { + return (ResettableListIterator<E>) RESETTABLE_INSTANCE; + } + + /** + * Get a typed instance of the iterator. + * @param <E> + * @return {@link ListIterator}<E> + */ + @SuppressWarnings("unchecked") + public static <E> ListIterator<E> getInstance() { + return (ListIterator<E>) INSTANCE; + } /** * Constructor. http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/EmptyMapIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/EmptyMapIterator.java b/src/java/org/apache/commons/collections/iterators/EmptyMapIterator.java index c0d0a46..e8d5c39 100644 --- a/src/java/org/apache/commons/collections/iterators/EmptyMapIterator.java +++ b/src/java/org/apache/commons/collections/iterators/EmptyMapIterator.java @@ -27,13 +27,25 @@ import org.apache.commons.collections.ResettableIterator; * * @author Stephen Colebourne */ -public class EmptyMapIterator extends AbstractEmptyIterator implements MapIterator, ResettableIterator { +public class EmptyMapIterator<K, V> extends AbstractEmptyMapIterator<K, V> implements + MapIterator<K, V>, ResettableIterator<K> { /** * Singleton instance of the iterator. * @since Commons Collections 3.1 */ - public static final MapIterator INSTANCE = new EmptyMapIterator(); + public static final MapIterator<Object, Object> INSTANCE = new EmptyMapIterator<Object, Object>(); + + /** + * Get a typed instance of the iterator. + * @param <K> + * @param <V> + * @return {@link MapIterator}<K, V> + */ + @SuppressWarnings("unchecked") + public static <K, V> MapIterator<K, V> getInstance() { + return (MapIterator<K, V>) INSTANCE; + } /** * Constructor. http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/EmptyOrderedIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/EmptyOrderedIterator.java b/src/java/org/apache/commons/collections/iterators/EmptyOrderedIterator.java index 2b7ca88..c90d816 100644 --- a/src/java/org/apache/commons/collections/iterators/EmptyOrderedIterator.java +++ b/src/java/org/apache/commons/collections/iterators/EmptyOrderedIterator.java @@ -27,13 +27,23 @@ import org.apache.commons.collections.ResettableIterator; * * @author Stephen Colebourne */ -public class EmptyOrderedIterator extends AbstractEmptyIterator implements OrderedIterator, ResettableIterator { +public class EmptyOrderedIterator<E> extends AbstractEmptyIterator<E> implements OrderedIterator<E>, ResettableIterator<E> { /** * Singleton instance of the iterator. * @since Commons Collections 3.1 */ - public static final OrderedIterator INSTANCE = new EmptyOrderedIterator(); + public static final OrderedIterator<Object> INSTANCE = new EmptyOrderedIterator<Object>(); + + /** + * Typed instance of the iterator. + * @param <E> + * @return OrderedIterator<E> + */ + @SuppressWarnings("unchecked") + public static <E> OrderedIterator<E> getInstance() { + return (OrderedIterator<E>) INSTANCE; + } /** * Constructor. http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/EmptyOrderedMapIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/EmptyOrderedMapIterator.java b/src/java/org/apache/commons/collections/iterators/EmptyOrderedMapIterator.java index af7523b..219982b 100644 --- a/src/java/org/apache/commons/collections/iterators/EmptyOrderedMapIterator.java +++ b/src/java/org/apache/commons/collections/iterators/EmptyOrderedMapIterator.java @@ -27,13 +27,25 @@ import org.apache.commons.collections.ResettableIterator; * * @author Stephen Colebourne */ -public class EmptyOrderedMapIterator extends AbstractEmptyIterator implements OrderedMapIterator, ResettableIterator { +public class EmptyOrderedMapIterator<K, V> extends AbstractEmptyMapIterator<K, V> implements + OrderedMapIterator<K, V>, ResettableIterator<K> { /** * Singleton instance of the iterator. * @since Commons Collections 3.1 */ - public static final OrderedMapIterator INSTANCE = new EmptyOrderedMapIterator(); + public static final OrderedMapIterator<Object, Object> INSTANCE = new EmptyOrderedMapIterator<Object, Object>(); + + /** + * Get a typed instance of the iterator. + * @param <K> + * @param <V> + * @return {@link OrderedMapIterator}<K, V> + */ + @SuppressWarnings("unchecked") + public static <K, V> OrderedMapIterator<K, V> getInstance() { + return (OrderedMapIterator<K, V>) INSTANCE; + } /** * Constructor. http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/EntrySetMapIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/EntrySetMapIterator.java b/src/java/org/apache/commons/collections/iterators/EntrySetMapIterator.java index 56c9fa0..1d73050 100644 --- a/src/java/org/apache/commons/collections/iterators/EntrySetMapIterator.java +++ b/src/java/org/apache/commons/collections/iterators/EntrySetMapIterator.java @@ -39,11 +39,11 @@ import org.apache.commons.collections.ResettableIterator; * * @author Stephen Colebourne */ -public class EntrySetMapIterator implements MapIterator, ResettableIterator { +public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableIterator<K> { - private final Map map; - private Iterator iterator; - private Map.Entry last; + private final Map<K, V> map; + private Iterator<Map.Entry<K, V>> iterator; + private Map.Entry<K, V> last; private boolean canRemove = false; /** @@ -51,7 +51,7 @@ public class EntrySetMapIterator implements MapIterator, ResettableIterator { * * @param map the map to iterate over */ - public EntrySetMapIterator(Map map) { + public EntrySetMapIterator(Map<K, V> map) { super(); this.map = map; this.iterator = map.entrySet().iterator(); @@ -73,8 +73,8 @@ public class EntrySetMapIterator implements MapIterator, ResettableIterator { * @return the next key in the iteration * @throws java.util.NoSuchElementException if the iteration is finished */ - public Object next() { - last = (Map.Entry) iterator.next(); + public K next() { + last = (Map.Entry<K, V>) iterator.next(); canRemove = true; return last.getKey(); } @@ -107,7 +107,7 @@ public class EntrySetMapIterator implements MapIterator, ResettableIterator { * @return the current key * @throws IllegalStateException if <code>next()</code> has not yet been called */ - public Object getKey() { + public K getKey() { if (last == null) { throw new IllegalStateException("Iterator getKey() can only be called after next() and before remove()"); } @@ -121,7 +121,7 @@ public class EntrySetMapIterator implements MapIterator, ResettableIterator { * @return the current value * @throws IllegalStateException if <code>next()</code> has not yet been called */ - public Object getValue() { + public V getValue() { if (last == null) { throw new IllegalStateException("Iterator getValue() can only be called after next() and before remove()"); } @@ -138,7 +138,7 @@ public class EntrySetMapIterator implements MapIterator, ResettableIterator { * @throws IllegalStateException if <code>remove()</code> has been called since the * last call to <code>next()</code> */ - public Object setValue(Object value) { + public V setValue(V value) { if (last == null) { throw new IllegalStateException("Iterator setValue() can only be called after next() and before remove()"); } @@ -163,9 +163,8 @@ public class EntrySetMapIterator implements MapIterator, ResettableIterator { public String toString() { if (last != null) { return "MapIterator[" + getKey() + "=" + getValue() + "]"; - } else { - return "MapIterator[]"; } + return "MapIterator[]"; } } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/EnumerationIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/EnumerationIterator.java b/src/java/org/apache/commons/collections/iterators/EnumerationIterator.java index a3e6631..4fef2ae 100644 --- a/src/java/org/apache/commons/collections/iterators/EnumerationIterator.java +++ b/src/java/org/apache/commons/collections/iterators/EnumerationIterator.java @@ -30,14 +30,14 @@ import java.util.Iterator; * @author <a href="mailto:jstrac...@apache.org";>James Strachan</a> * @author <a href="mailto:d...@finemaltcoding.com";>Daniel Rall</a> */ -public class EnumerationIterator implements Iterator { +public class EnumerationIterator<E> implements Iterator<E> { /** The collection to remove elements from */ - private Collection collection; + private Collection<? super E> collection; /** The enumeration being converted */ - private Enumeration enumeration; + private Enumeration<? extends E> enumeration; /** The last object retrieved */ - private Object last; + private E last; // Constructors //----------------------------------------------------------------------- @@ -55,7 +55,7 @@ public class EnumerationIterator implements Iterator { * * @param enumeration the enumeration to use */ - public EnumerationIterator(final Enumeration enumeration) { + public EnumerationIterator(final Enumeration<? extends E> enumeration) { this(enumeration, null); } @@ -64,9 +64,9 @@ public class EnumerationIterator implements Iterator { * elements from the specified collection. * * @param enumeration the enumeration to use - * @param collection the collection to remove elements form + * @param collection the collection to remove elements from */ - public EnumerationIterator(final Enumeration enumeration, final Collection collection) { + public EnumerationIterator(final Enumeration<? extends E> enumeration, final Collection<? super E> collection) { super(); this.enumeration = enumeration; this.collection = collection; @@ -91,7 +91,7 @@ public class EnumerationIterator implements Iterator { * @return the next object from the enumeration * @throws NullPointerException if the enumeration is null */ - public Object next() { + public E next() { last = enumeration.nextElement(); return last; } @@ -125,7 +125,7 @@ public class EnumerationIterator implements Iterator { * * @return the underlying enumeration */ - public Enumeration getEnumeration() { + public Enumeration<? extends E> getEnumeration() { return enumeration; } @@ -134,7 +134,7 @@ public class EnumerationIterator implements Iterator { * * @param enumeration the new underlying enumeration */ - public void setEnumeration(final Enumeration enumeration) { + public void setEnumeration(final Enumeration<? extends E> enumeration) { this.enumeration = enumeration; } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/FilterIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/FilterIterator.java b/src/java/org/apache/commons/collections/iterators/FilterIterator.java index e14959d..6d8c8ca 100644 --- a/src/java/org/apache/commons/collections/iterators/FilterIterator.java +++ b/src/java/org/apache/commons/collections/iterators/FilterIterator.java @@ -35,14 +35,14 @@ import org.apache.commons.collections.Predicate; * @author Ralph Wagner * @author Stephen Colebourne */ -public class FilterIterator implements Iterator { +public class FilterIterator<E> implements Iterator<E> { /** The iterator being used */ - private Iterator iterator; + private Iterator<? extends E> iterator; /** The predicate being used */ - private Predicate predicate; + private Predicate<? super E> predicate; /** The next object in the iteration */ - private Object nextObject; + private E nextObject; /** Whether the next object has been calculated yet */ private boolean nextObjectSet = false; @@ -61,7 +61,7 @@ public class FilterIterator implements Iterator { * * @param iterator the iterator to use */ - public FilterIterator(Iterator iterator) { + public FilterIterator(Iterator<? extends E> iterator) { super(); this.iterator = iterator; } @@ -73,7 +73,7 @@ public class FilterIterator implements Iterator { * @param iterator the iterator to use * @param predicate the predicate to use */ - public FilterIterator(Iterator iterator, Predicate predicate) { + public FilterIterator(Iterator<? extends E> iterator, Predicate<? super E> predicate) { super(); this.iterator = iterator; this.predicate = predicate; @@ -88,11 +88,7 @@ public class FilterIterator implements Iterator { * @throws NullPointerException if either the iterator or predicate are null */ public boolean hasNext() { - if (nextObjectSet) { - return true; - } else { - return setNextObject(); - } + return nextObjectSet || setNextObject(); } /** @@ -103,7 +99,7 @@ public class FilterIterator implements Iterator { * @throws NoSuchElementException if there are no more elements that * match the predicate */ - public Object next() { + public E next() { if (!nextObjectSet) { if (!setNextObject()) { throw new NoSuchElementException(); @@ -137,7 +133,7 @@ public class FilterIterator implements Iterator { * * @return the iterator */ - public Iterator getIterator() { + public Iterator<? extends E> getIterator() { return iterator; } @@ -147,7 +143,7 @@ public class FilterIterator implements Iterator { * * @param iterator the iterator to use */ - public void setIterator(Iterator iterator) { + public void setIterator(Iterator<? extends E> iterator) { this.iterator = iterator; nextObject = null; nextObjectSet = false; @@ -159,7 +155,7 @@ public class FilterIterator implements Iterator { * * @return the predicate */ - public Predicate getPredicate() { + public Predicate<? super E> getPredicate() { return predicate; } @@ -168,7 +164,7 @@ public class FilterIterator implements Iterator { * * @param predicate the predicate to use */ - public void setPredicate(Predicate predicate) { + public void setPredicate(Predicate<? super E> predicate) { this.predicate = predicate; nextObject = null; nextObjectSet = false; @@ -181,7 +177,7 @@ public class FilterIterator implements Iterator { */ private boolean setNextObject() { while (iterator.hasNext()) { - Object object = iterator.next(); + E object = iterator.next(); if (predicate.evaluate(object)) { nextObject = object; nextObjectSet = true; http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/java/org/apache/commons/collections/iterators/FilterListIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/commons/collections/iterators/FilterListIterator.java b/src/java/org/apache/commons/collections/iterators/FilterListIterator.java index 8a64ef5..36321fa 100644 --- a/src/java/org/apache/commons/collections/iterators/FilterListIterator.java +++ b/src/java/org/apache/commons/collections/iterators/FilterListIterator.java @@ -32,19 +32,19 @@ import org.apache.commons.collections.Predicate; * * @author Rodney Waldhoff */ -public class FilterListIterator implements ListIterator { +public class FilterListIterator<E> implements ListIterator<E> { /** The iterator being used */ - private ListIterator iterator; + private ListIterator<? extends E> iterator; /** The predicate being used */ - private Predicate predicate; + private Predicate<? super E> predicate; /** * The value of the next (matching) object, when * {@link #nextObjectSet} is true. */ - private Object nextObject; + private E nextObject; /** * Whether or not the {@link #nextObject} has been set @@ -56,7 +56,7 @@ public class FilterListIterator implements ListIterator { * The value of the previous (matching) object, when * {@link #previousObjectSet} is true. */ - private Object previousObject; + private E previousObject; /** * Whether or not the {@link #previousObject} has been set @@ -85,7 +85,7 @@ public class FilterListIterator implements ListIterator { * * @param iterator the iterator to use */ - public FilterListIterator(ListIterator iterator ) { + public FilterListIterator(ListIterator<? extends E> iterator ) { super(); this.iterator = iterator; } @@ -96,7 +96,7 @@ public class FilterListIterator implements ListIterator { * @param iterator the iterator to use * @param predicate the predicate to use */ - public FilterListIterator(ListIterator iterator, Predicate predicate) { + public FilterListIterator(ListIterator<? extends E> iterator, Predicate<? super E> predicate) { super(); this.iterator = iterator; this.predicate = predicate; @@ -108,41 +108,33 @@ public class FilterListIterator implements ListIterator { * * @param predicate the predicate to use. */ - public FilterListIterator(Predicate predicate) { + public FilterListIterator(Predicate<? super E> predicate) { super(); this.predicate = predicate; } //----------------------------------------------------------------------- /** Not supported. */ - public void add(Object o) { + public void add(E o) { throw new UnsupportedOperationException("FilterListIterator.add(Object) is not supported."); } public boolean hasNext() { - if(nextObjectSet) { - return true; - } else { - return setNextObject(); - } + return nextObjectSet || setNextObject(); } public boolean hasPrevious() { - if(previousObjectSet) { - return true; - } else { - return setPreviousObject(); - } + return previousObjectSet || setPreviousObject(); } - public Object next() { - if(!nextObjectSet) { - if(!setNextObject()) { + public E next() { + if (!nextObjectSet) { + if (!setNextObject()) { throw new NoSuchElementException(); } } nextIndex++; - Object temp = nextObject; + E temp = nextObject; clearNextObject(); return temp; } @@ -151,14 +143,14 @@ public class FilterListIterator implements ListIterator { return nextIndex; } - public Object previous() { - if(!previousObjectSet) { - if(!setPreviousObject()) { + public E previous() { + if (!previousObjectSet) { + if (!setPreviousObject()) { throw new NoSuchElementException(); } } nextIndex--; - Object temp = previousObject; + E temp = previousObject; clearPreviousObject(); return temp; } @@ -173,7 +165,7 @@ public class FilterListIterator implements ListIterator { } /** Not supported. */ - public void set(Object o) { + public void set(E o) { throw new UnsupportedOperationException("FilterListIterator.set(Object) is not supported."); } @@ -183,7 +175,7 @@ public class FilterListIterator implements ListIterator { * * @return the iterator. */ - public ListIterator getListIterator() { + public ListIterator<? extends E> getListIterator() { return iterator; } @@ -193,7 +185,7 @@ public class FilterListIterator implements ListIterator { * * @param iterator the iterator to use */ - public void setListIterator(ListIterator iterator) { + public void setListIterator(ListIterator<? extends E> iterator) { this.iterator = iterator; } @@ -203,7 +195,7 @@ public class FilterListIterator implements ListIterator { * * @return the predicate. */ - public Predicate getPredicate() { + public Predicate<? super E> getPredicate() { return predicate; } @@ -212,7 +204,7 @@ public class FilterListIterator implements ListIterator { * * @param predicate the transformer to use */ - public void setPredicate(Predicate predicate) { + public void setPredicate(Predicate<? super E> predicate) { this.predicate = predicate; } @@ -227,18 +219,17 @@ public class FilterListIterator implements ListIterator { // then we've walked back one step in the // underlying list (due to a hasPrevious() call) // so skip ahead one matching object - if(previousObjectSet) { + if (previousObjectSet) { clearPreviousObject(); - if(!setNextObject()) { + if (!setNextObject()) { return false; - } else { - clearNextObject(); } + clearNextObject(); } - while(iterator.hasNext()) { - Object object = iterator.next(); - if(predicate.evaluate(object)) { + while (iterator.hasNext()) { + E object = iterator.next(); + if (predicate.evaluate(object)) { nextObject = object; nextObjectSet = true; return true; @@ -257,18 +248,17 @@ public class FilterListIterator implements ListIterator { // then we've walked back one step in the // underlying list (due to a hasNext() call) // so skip ahead one matching object - if(nextObjectSet) { + if (nextObjectSet) { clearNextObject(); - if(!setPreviousObject()) { + if (!setPreviousObject()) { return false; - } else { - clearPreviousObject(); } + clearPreviousObject(); } - while(iterator.hasPrevious()) { - Object object = iterator.previous(); - if(predicate.evaluate(object)) { + while (iterator.hasPrevious()) { + E object = iterator.previous(); + if (predicate.evaluate(object)) { previousObject = object; previousObjectSet = true; return true;
