Apache
/
commons-collections
mirror of https://github.com/apache/commons-collections.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merging from -r468106:814127 of collections_jdk5_branch - namely where this code was generified; mostly in r738956. 

Also see the following revisions:

    ------------------------------------------------------------------------
    r643795 | skestle | 2008-04-02 01:49:57 -0700 (Wed, 02 Apr 2008) | 5 lines
    
    Generified EqualPredicate and created individual test class moved from TestPredicateUtils
    
    Added assertFalse() and assertTrue to BasicPredicateTestBase with (Predicate, Object) parameters
    
    Issues: COLLECTIONS-243, COLLECTIONS-253, COLLECTIONS-293
    ------------------------------------------------------------------------


git-svn-id: https://svn.apache.org/repos/asf/commons/proper/collections/trunk@815106 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Henri Yandell 2009-09-15 05:56:51 +00:00
parent 9a80db63cc
commit 43f9c6f97f
1 changed files with 56 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
src/java/org/apache/commons/collections/TransformerUtils.java
View File

@ -17,7 +17,6 @@
package org.apache.commons.collections; package org.apache.commons.collections;
import java.util.Collection; import java.util.Collection;
import java.util.Iterator;
import java.util.Map; import java.util.Map;
import org.apache.commons.collections.functors.ChainedTransformer; import org.apache.commons.collections.functors.ChainedTransformer;
@ -80,8 +79,8 @@ public class TransformerUtils {
* *
* @return the transformer * @return the transformer
*/ */
public static Transformer exceptionTransformer() { public static <I, O> Transformer<I, O> exceptionTransformer() {
return ExceptionTransformer.INSTANCE; return ExceptionTransformer.<I, O>getInstance();
} }
/** /**
@ -91,8 +90,8 @@ public class TransformerUtils {
* *
* @return the transformer * @return the transformer
*/ */
public static Transformer nullTransformer() { public static <I, O> Transformer<I, O> nullTransformer() {
return ConstantTransformer.NULL_INSTANCE; return ConstantTransformer.<I, O>getNullInstance();
} }
/** /**
@ -104,8 +103,8 @@ public class TransformerUtils {
* *
* @return the transformer * @return the transformer
*/ */
public static Transformer nopTransformer() { public static <T> Transformer<T, T> nopTransformer() {
return NOPTransformer.INSTANCE; return NOPTransformer.<T>getInstance();
} }
/** /**
@ -122,8 +121,8 @@ public class TransformerUtils {
* *
* @return the transformer * @return the transformer
*/ */
public static Transformer cloneTransformer() { public static <T> Transformer<T, T> cloneTransformer() {
return CloneTransformer.INSTANCE; return CloneTransformer.<T>getInstance();
} }
/** /**
@ -135,7 +134,7 @@ public class TransformerUtils {
* @param constantToReturn the constant object to return each time in the transformer * @param constantToReturn the constant object to return each time in the transformer
* @return the transformer. * @return the transformer.
*/ */
public static Transformer constantTransformer(Object constantToReturn) { public static <I, O> Transformer<I, O> constantTransformer(O constantToReturn) {
return ConstantTransformer.getInstance(constantToReturn); return ConstantTransformer.getInstance(constantToReturn);
} }
@ -149,7 +148,7 @@ public class TransformerUtils {
* @return the transformer * @return the transformer
* @throws IllegalArgumentException if the closure is null * @throws IllegalArgumentException if the closure is null
*/ */
public static Transformer asTransformer(Closure closure) { public static <T> Transformer<T, T> asTransformer(Closure<? super T> closure) {
return ClosureTransformer.getInstance(closure); return ClosureTransformer.getInstance(closure);
} }
@ -163,7 +162,7 @@ public class TransformerUtils {
* @return the transformer * @return the transformer
* @throws IllegalArgumentException if the predicate is null * @throws IllegalArgumentException if the predicate is null
*/ */
public static Transformer asTransformer(Predicate predicate) { public static <T> Transformer<T, Boolean> asTransformer(Predicate<? super T> predicate) {
return PredicateTransformer.getInstance(predicate); return PredicateTransformer.getInstance(predicate);
} }
@ -177,7 +176,7 @@ public class TransformerUtils {
* @return the transformer * @return the transformer
* @throws IllegalArgumentException if the factory is null * @throws IllegalArgumentException if the factory is null
*/ */
public static Transformer asTransformer(Factory factory) { public static <I, O> Transformer<I, O> asTransformer(Factory<? extends O> factory) {
return FactoryTransformer.getInstance(factory); return FactoryTransformer.getInstance(factory);
} }
@ -192,8 +191,10 @@ public class TransformerUtils {
* @return the transformer * @return the transformer
* @throws IllegalArgumentException if either transformer is null * @throws IllegalArgumentException if either transformer is null
*/ */
public static Transformer chainedTransformer(Transformer transformer1, Transformer transformer2) { public static <T> Transformer<T, T> chainedTransformer(
return ChainedTransformer.getInstance(transformer1, transformer2); Transformer<? super T, ? extends T> transformer1,
Transformer<? super T, ? extends T> transformer2) {
return ChainedTransformer.<T>getInstance(transformer1, transformer2);
} }
/** /**
@ -207,7 +208,7 @@ public class TransformerUtils {
* @throws IllegalArgumentException if the transformers array is null * @throws IllegalArgumentException if the transformers array is null
* @throws IllegalArgumentException if any transformer in the array is null * @throws IllegalArgumentException if any transformer in the array is null
*/ */
public static Transformer chainedTransformer(Transformer[] transformers) { public static <T> Transformer<T, T> chainedTransformer(Transformer<? super T, ? extends T>[] transformers) {
return ChainedTransformer.getInstance(transformers); return ChainedTransformer.getInstance(transformers);
} }
@ -223,7 +224,8 @@ public class TransformerUtils {
* @throws IllegalArgumentException if the transformers collection is null * @throws IllegalArgumentException if the transformers collection is null
* @throws IllegalArgumentException if any transformer in the collection is null * @throws IllegalArgumentException if any transformer in the collection is null
*/ */
public static Transformer chainedTransformer(Collection transformers) { public static <T> Transformer<T, T> chainedTransformer(
Collection<? extends Transformer<T, T>> transformers) {
return ChainedTransformer.getInstance(transformers); return ChainedTransformer.getInstance(transformers);
} }
@ -240,8 +242,12 @@ public class TransformerUtils {
* @throws IllegalArgumentException if the predicate is null * @throws IllegalArgumentException if the predicate is null
* @throws IllegalArgumentException if either transformer is null * @throws IllegalArgumentException if either transformer is null
*/ */
public static Transformer switchTransformer(Predicate predicate, Transformer trueTransformer, Transformer falseTransformer) { @SuppressWarnings("unchecked")
return SwitchTransformer.getInstance(new Predicate[] { predicate }, new Transformer[] { trueTransformer }, falseTransformer); public static <I, O> Transformer<I, O> switchTransformer(Predicate<? super I> predicate,
Transformer<? super I, ? extends O> trueTransformer,
Transformer<? super I, ? extends O> falseTransformer) {
return SwitchTransformer.getInstance(new Predicate[] { predicate },
new Transformer[] { trueTransformer }, falseTransformer);
} }
/** /**
@ -260,8 +266,9 @@ public class TransformerUtils {
* @throws IllegalArgumentException if any element in the arrays is null * @throws IllegalArgumentException if any element in the arrays is null
* @throws IllegalArgumentException if the arrays are different sizes * @throws IllegalArgumentException if the arrays are different sizes
*/ */
public static Transformer switchTransformer(Predicate[] predicates, Transformer[] transformers) { public static <I, O> Transformer<I, O> switchTransformer(Predicate<? super I>[] predicates,
return SwitchTransformer.getInstance(predicates, transformers, null); Transformer<? super I, ? extends O>[] transformers) {
return SwitchTransformer.<I, O>getInstance(predicates, transformers, null);
} }
/** /**
@ -282,8 +289,10 @@ public class TransformerUtils {
* @throws IllegalArgumentException if any element in the arrays is null * @throws IllegalArgumentException if any element in the arrays is null
* @throws IllegalArgumentException if the arrays are different sizes * @throws IllegalArgumentException if the arrays are different sizes
*/ */
public static Transformer switchTransformer(Predicate[] predicates, Transformer[] transformers, Transformer defaultTransformer) { public static <I, O> Transformer<I, O> switchTransformer(Predicate<? super I>[] predicates,
return SwitchTransformer.getInstance(predicates, transformers, defaultTransformer); Transformer<? super I, ? extends O>[] transformers,
Transformer<? super I, ? extends O> defaultTransformer) {
return SwitchTransformer.<I, O>getInstance(predicates, transformers, defaultTransformer);
} }
/** /**
@ -307,8 +316,9 @@ public class TransformerUtils {
* @throws IllegalArgumentException if any transformer in the map is null * @throws IllegalArgumentException if any transformer in the map is null
* @throws ClassCastException if the map elements are of the wrong type * @throws ClassCastException if the map elements are of the wrong type
*/ */
public static Transformer switchTransformer(Map predicatesAndTransformers) { public static <I, O> Transformer<I, O> switchTransformer(
return SwitchTransformer.getInstance(predicatesAndTransformers); Map<Predicate<I>, Transformer<I, O>> predicatesAndTransformers) {
return SwitchTransformer.<I, O>getInstance(predicatesAndTransformers);
} }
/** /**
@ -328,24 +338,23 @@ public class TransformerUtils {
* @throws IllegalArgumentException if the map is empty * @throws IllegalArgumentException if the map is empty
* @throws IllegalArgumentException if any transformer in the map is null * @throws IllegalArgumentException if any transformer in the map is null
*/ */
public static Transformer switchMapTransformer(Map objectsAndTransformers) { @SuppressWarnings("unchecked")
Transformer[] trs = null; public static <I, O> Transformer<I, O> switchMapTransformer(Map<I, Transformer<I, O>> objectsAndTransformers) {
Predicate[] preds = null; Transformer<? super I, ? extends O>[] trs = null;
Predicate<I>[] preds = null;
if (objectsAndTransformers == null) { if (objectsAndTransformers == null) {
throw new IllegalArgumentException("The object and transformer map must not be null"); throw new IllegalArgumentException("The object and transformer map must not be null");
} }
Transformer def = (Transformer) objectsAndTransformers.remove(null); Transformer<? super I, ? extends O> def = objectsAndTransformers.remove(null);
int size = objectsAndTransformers.size(); int size = objectsAndTransformers.size();
trs = new Transformer[size]; trs = new Transformer[size];
preds = new Predicate[size]; preds = new Predicate[size];
int i = 0; int i = 0;
for (Iterator it = objectsAndTransformers.entrySet().iterator(); it.hasNext();) { for (Map.Entry<I, Transformer<I, O>> entry : objectsAndTransformers.entrySet()) {
Map.Entry entry = (Map.Entry) it.next(); preds[i] = EqualPredicate.<I>equalPredicate(entry.getKey());
preds[i] = EqualPredicate.getInstance(entry.getKey()); trs[i++] = entry.getValue();
trs[i] = (Transformer) entry.getValue();
i++;
} }
return switchTransformer(preds, trs, def); return TransformerUtils.<I, O>switchTransformer(preds, trs, def);
} }
/** /**
@ -355,8 +364,8 @@ public class TransformerUtils {
* *
* @return the transformer * @return the transformer
*/ */
public static Transformer instantiateTransformer() { public static <T> Transformer<Class<? extends T>, T> instantiateTransformer() {
return InstantiateTransformer.NO_ARG_INSTANCE; return InstantiateTransformer.<T>getInstance();
} }
/** /**
@ -371,8 +380,9 @@ public class TransformerUtils {
* @return the transformer * @return the transformer
* @throws IllegalArgumentException if the paramTypes and args don't match * @throws IllegalArgumentException if the paramTypes and args don't match
*/ */
public static Transformer instantiateTransformer(Class[] paramTypes, Object[] args) { public static <T> Transformer<Class<? extends T>, T> instantiateTransformer(
return InstantiateTransformer.getInstance(paramTypes, args); Class<?>[] paramTypes, Object[] args) {
return InstantiateTransformer.<T>getInstance(paramTypes, args);
} }
/** /**
@ -385,7 +395,7 @@ public class TransformerUtils {
* @return the transformer * @return the transformer
* @throws IllegalArgumentException if the map is null * @throws IllegalArgumentException if the map is null
*/ */
public static Transformer mapTransformer(Map map) { public static <I, O> Transformer<I, O> mapTransformer(Map<? super I, ? extends O> map) {
return MapTransformer.getInstance(map); return MapTransformer.getInstance(map);
} }
@ -404,8 +414,8 @@ public class TransformerUtils {
* @return the transformer * @return the transformer
* @throws IllegalArgumentException if the methodName is null. * @throws IllegalArgumentException if the methodName is null.
*/ */
public static Transformer invokerTransformer(String methodName){ public static <I, O> Transformer<I, O> invokerTransformer(String methodName){
return InvokerTransformer.getInstance(methodName, null, null); return InvokerTransformer.<I, O>getInstance(methodName, null, null);
} }
/** /**
@ -422,8 +432,8 @@ public class TransformerUtils {
* @throws IllegalArgumentException if the method name is null * @throws IllegalArgumentException if the method name is null
* @throws IllegalArgumentException if the paramTypes and args don't match * @throws IllegalArgumentException if the paramTypes and args don't match
*/ */
public static Transformer invokerTransformer(String methodName, Class[] paramTypes, Object[] args){ public static <I, O> Transformer<I, O> invokerTransformer(String methodName, Class<?>[] paramTypes, Object[] args){
return InvokerTransformer.getInstance(methodName, paramTypes, args); return InvokerTransformer.<I, O>getInstance(methodName, paramTypes, args);
} }
/** /**
@ -435,8 +445,8 @@ public class TransformerUtils {
* *
* @return the transformer * @return the transformer
*/ */
public static Transformer stringValueTransformer() { public static <T> Transformer<T, String> stringValueTransformer() {
return StringValueTransformer.INSTANCE; return StringValueTransformer.<T>getInstance();
} }
} }