commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scolebou...@apache.org
Subject cvs commit: jakarta-commons/lang/src/java/org/apache/commons/lang/functor FactoryUtils.java TransformerUtils.java PredicateUtils.java ExecutorUtils.java
Date Thu, 14 Nov 2002 21:54:49 GMT
scolebourne    2002/11/14 13:54:49

  Modified:    lang/src/java/org/apache/commons/lang/functor
                        FactoryUtils.java TransformerUtils.java
                        PredicateUtils.java ExecutorUtils.java
  Log:
  Javadoc improvements.
  Finish renaming of Command to Executor.
  
  Revision  Changes    Path
  1.2       +17 -12    jakarta-commons/lang/src/java/org/apache/commons/lang/functor/FactoryUtils.java
  
  Index: FactoryUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/functor/FactoryUtils.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- FactoryUtils.java	5 Nov 2002 16:44:28 -0000	1.1
  +++ FactoryUtils.java	14 Nov 2002 21:54:49 -0000	1.2
  @@ -62,7 +62,7 @@
   import org.apache.commons.lang.SerializationUtils;
   /**
    * <code>FactoryUtils</code> provides reference implementations and utilities
  - * for the Factory pattern interface. The supplied factories are:
  + * for the Factory functor interface. The supplied factories are:
    * <ul>
    * <li>Prototype - clones a specified object
    * <li>Reflection - creates objects using reflection
  @@ -105,6 +105,7 @@
   
       /**
        * Gets a Factory that will return null each time the factory is used.
  +     * This could be useful during testing as a placeholder.
        *
        * @return the factory
        */
  @@ -119,7 +120,7 @@
        * use the prototype factory.
        *
        * @param constantToReturn  the constant object to return each time in the factory
  -     * @return the factory.
  +     * @return the <code>constant</code> factory.
        */
       public static Factory constantFactory(Object constantToReturn) {
           return new ConstantFactory(constantToReturn);
  @@ -136,15 +137,14 @@
        * <ul>
        *
        * @param prototype  the object to clone each time in the factory
  -     * @return the factory
  +     * @return the <code>prototype</code> factory
        * @throws IllegalArgumentException if the prototype is null
        * @throws IllegalArgumentException if the prototype cannot be cloned
        */
       public static Factory prototypeFactory(Object prototype) {
           if (prototype == null) {
  -            throw new IllegalArgumentException("PrototypeFactory: The prototype must not be null");
  +            throw new IllegalArgumentException("The prototype must not be null");
           }
  -        // TODO: move to cloneable pattern
           try {
               prototype.getClass().getMethod("clone", null);
               return new PrototypeCloneFactory(prototype);
  @@ -160,7 +160,7 @@
                   }
               }
           }
  -        throw new IllegalArgumentException("PrototypeFactory: The prototype must be cloneable");
  +        throw new IllegalArgumentException("The prototype must be cloneable via a public clone method");
       }
   
       /**
  @@ -168,7 +168,7 @@
        * a no-args constructor.
        *
        * @param classToInstantiate  the Class to instantiate each time in the factory
  -     * @return the factory
  +     * @return the <code>reflection</code> factory
        * @throws IllegalArgumentException if the classToInstantiate is null
        */
       public static Factory reflectionFactory(Class classToInstantiate) {
  @@ -182,7 +182,7 @@
        * @param classToInstantiate  the Class to instantiate each time in the factory
        * @param paramTypes  parameter types for the constructor, can be null
        * @param args  the arguments to pass to the constructor, can be null
  -     * @return the factory
  +     * @return the <code>reflection</code> factory
        * @throws IllegalArgumentException if the classToInstantiate is null
        * @throws IllegalArgumentException if the paramTypes and args don't match
        * @throws IllegalArgumentException if the constructor doesn't exist
  @@ -221,7 +221,7 @@
        * ConstantFactory returns the same instance each time.
        */
       private static class ConstantFactory implements Factory, Serializable {
  -
  +        /** The constant to return each time */
           private final Object iConstant;
   
           /**
  @@ -247,7 +247,9 @@
        * PrototypeCloneFactory creates objects by copying a prototype using the clone method.
        */
       private static class PrototypeCloneFactory implements Factory, Serializable {
  +        /** The object to clone each time */
           private final Object iPrototype;
  +        /** The method used to clone */
           private transient Method iCloneMethod;
   
           /**
  @@ -302,7 +304,7 @@
        * PrototypeSerializationFactory creates objects by cloning a prototype using serialization.
        */
       private static class PrototypeSerializationFactory implements Factory, Serializable {
  -
  +        /** The object to clone via serialization each time */
           private final Serializable iPrototype;
   
           /**
  @@ -336,10 +338,13 @@
        * ReflectionFactory creates objects using reflection.
        */
       private static class ReflectionFactory implements Factory, Serializable {
  -
  +        /** The class to create */
           private final Class iClassToInstantiate;
  +        /** The constructor parameter types */
           private final Class[] iParamTypes;
  +        /** The constructor arguments */
           private final Object[] iArgs;
  +        /** The constructor */
           private transient Constructor iConstructor = null;
   
           /**
  
  
  
  1.3       +54 -49    jakarta-commons/lang/src/java/org/apache/commons/lang/functor/TransformerUtils.java
  
  Index: TransformerUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/functor/TransformerUtils.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- TransformerUtils.java	6 Nov 2002 19:16:33 -0000	1.2
  +++ TransformerUtils.java	14 Nov 2002 21:54:49 -0000	1.3
  @@ -59,10 +59,9 @@
   import java.util.Collection;
   import java.util.Iterator;
   import java.util.Map;
  -
   /**
    * <code>TransformerUtils</code> provides reference implementations and 
  - * utilities for the Transformer pattern interface. The supplied transformers are:
  + * utilities for the Transformer functor interface. The supplied transformers are:
    * <ul>
    * <li>Invoker - returns the result of a method call on the input object
    * <li>Clone - returns a clone of the input object
  @@ -178,11 +177,11 @@
        * @param command  the command to run each time in the transformer
        * @return the transformer.
        */
  -    public static Transformer asTransformer(Executor command) {
  -        if (command == null) {
  -            throw new IllegalArgumentException("ExecutorTransformer: The command must not be null");
  +    public static Transformer asTransformer(Executor executor) {
  +        if (executor == null) {
  +            throw new IllegalArgumentException("The executor must not be null");
           }
  -        return new ExecutorTransformer(command);
  +        return new ExecutorTransformer(executor);
       }
   
       /**
  @@ -194,7 +193,7 @@
        */
       public static Transformer asTransformer(Predicate predicate) {
           if (predicate == null) {
  -            throw new IllegalArgumentException("PredicateTransformer: The predicate must not be null");
  +            throw new IllegalArgumentException("The predicate must not be null");
           }
           return new PredicateTransformer(predicate);
       }
  @@ -208,7 +207,7 @@
        */
       public static Transformer asTransformer(Factory factory) {
           if (factory == null) {
  -            throw new IllegalArgumentException("FactoryTransformer: The factory must not be null");
  +            throw new IllegalArgumentException("The factory must not be null");
           }
           return new FactoryTransformer(factory);
       }
  @@ -258,7 +257,7 @@
       public static Transformer chainedTransformer(Collection transformers) {
           Transformer[] trs = null;
           if (transformers == null) {
  -            throw new IllegalArgumentException("ChainedTransformer: The transformer collection must not be null");
  +            throw new IllegalArgumentException("The transformer collection must not be null");
           }
           // convert to array like this to guarantee iterator() ordering
           trs = new Transformer[transformers.size()];
  @@ -346,7 +345,7 @@
           Transformer[] trs = null;
           Predicate[] preds = null;
           if (predicatesAndTransformers == null) {
  -            throw new IllegalArgumentException("SwitchTransformer: The predicate and transformer map must not be null");
  +            throw new IllegalArgumentException("The predicate and transformer map must not be null");
           }
           // convert to array like this to guarantee iterator() ordering
           Transformer def = (Transformer) predicatesAndTransformers.remove(null);
  @@ -370,7 +369,7 @@
           validate(predicates);
           validate(transformers);
           if (predicates.length != transformers.length) {
  -            throw new IllegalArgumentException("SwitchTransformer: The predicate and transformer arrays must be the same size");
  +            throw new IllegalArgumentException("The predicate and transformer arrays must be the same size");
           }
           if (defaultTransformer == null) {
               defaultTransformer = nullTransformer();
  @@ -397,7 +396,7 @@
           Transformer[] trs = null;
           Predicate[] preds = null;
           if (objectsAndTransformers == null) {
  -            throw new IllegalArgumentException("SwitchEqualsTransformer: The obejct and transformer map must not be null");
  +            throw new IllegalArgumentException("The obejct and transformer map must not be null");
           }
           Transformer def = (Transformer) objectsAndTransformers.remove(null);
           int size = objectsAndTransformers.size();
  @@ -446,7 +445,7 @@
        */
       public static Transformer mapTransformer(Map map) {
           if (map == null) {
  -            throw new IllegalArgumentException("MapTransformer: The map must not be null");
  +            throw new IllegalArgumentException("The map must not be null");
           }
           return new MapTransformer(map);
       }
  @@ -503,16 +502,16 @@
        */
       private static void validate(Predicate[] predicates) {
           if (predicates == null) {
  -            throw new IllegalArgumentException("TransformerUtils: The predicate array must not be null");
  +            throw new IllegalArgumentException("The predicate array must not be null");
           }
           if (predicates.length < 1) {
               throw new IllegalArgumentException(
  -                "TransformerUtils: At least 1 predicate must be specified in the predicate array, size was " + predicates.length);
  +                "At least 1 predicate must be specified in the predicate array, size was " + predicates.length);
           }
           for (int i = 0; i < predicates.length; i++) {
               if (predicates[i] == null) {
                   throw new IllegalArgumentException(
  -                    "TransformerUtils: The predicate array must not contain a null predicate, index " + i + " was null");
  +                    "The predicate array must not contain a null predicate, index " + i + " was null");
               }
           }
       }
  @@ -536,16 +535,16 @@
        */
       private static void validate(Transformer[] transformers) {
           if (transformers == null) {
  -            throw new IllegalArgumentException("TransformerUtils: The transformer array must not be null");
  +            throw new IllegalArgumentException("The transformer array must not be null");
           }
           if (transformers.length < 1) {
               throw new IllegalArgumentException(
  -                "TransformerUtils: At least 1 transformer must be specified in the transformer array, size was " + transformers.length);
  +                "At least 1 transformer must be specified in the transformer array, size was " + transformers.length);
           }
           for (int i = 0; i < transformers.length; i++) {
               if (transformers[i] == null) {
                   throw new IllegalArgumentException(
  -                    "TransformerUtils: The transformer array must not contain a null transformer, index " + i + " was null");
  +                    "The transformer array must not contain a null transformer, index " + i + " was null");
               }
           }
       }
  @@ -636,11 +635,11 @@
        * ConstantTransformer returns the same instance each time.
        */
       private static class ConstantTransformer implements Transformer, Serializable {
  -
  +        /** The constant to return each time */
           private final Object iConstant;
   
           /**
  -         * Constructor to store constant
  +         * Constructor to store constant.
            */
           private ConstantTransformer(Object constant) {
               super();
  @@ -648,7 +647,7 @@
           }
   
           /**
  -         * Always return constant
  +         * Always return constant.
            */
           public Object transform(Object input) {
               return iConstant;
  @@ -662,19 +661,19 @@
        * ExecutorTransformer executes a Executor object.
        */
       private static class ExecutorTransformer implements Transformer, Serializable {
  -
  +        /** The executor to call each time */
           private final Executor iExecutor;
   
           /**
  -         * Constructor to store command
  +         * Constructor to store executor.
            */
  -        private ExecutorTransformer(Executor command) {
  +        private ExecutorTransformer(Executor executor) {
               super();
  -            iExecutor = command;
  +            iExecutor = executor;
           }
   
           /**
  -         * Exceute the command and return the input
  +         * Exceute the executor and return the input.
            */
           public Object transform(Object input) {
               try {
  @@ -694,11 +693,11 @@
        * PredicateTransformer evaluates a Predicate object.
        */
       private static class PredicateTransformer implements Transformer, Serializable {
  -
  +        /** The predicate to call each time */
           private final Predicate iPredicate;
   
           /**
  -         * Constructor to store predicate
  +         * Constructor to store predicate.
            */
           private PredicateTransformer(Predicate predicate) {
               super();
  @@ -706,7 +705,7 @@
           }
   
           /**
  -         * Evaluate the predicate and return the result as a Boolean
  +         * Evaluate the predicate and return the result as a Boolean.
            */
           public Object transform(Object input) {
               try {
  @@ -725,11 +724,11 @@
        * FactoryTransformer returns the result of calling a Factory.
        */
       private static class FactoryTransformer implements Transformer, Serializable {
  -
  +        /** The factory to call each time */
           private final Factory iFactory;
   
           /**
  -         * Constructor to store factory
  +         * Constructor to store factory.
            */
           private FactoryTransformer(Factory factory) {
               super();
  @@ -737,7 +736,7 @@
           }
   
           /**
  -         * Return the result of calling the factory
  +         * Return the result of calling the factory.
            */
           public Object transform(Object input) {
               try {
  @@ -756,11 +755,11 @@
        * ChainedTransformer returns the result of calling a list of transformers.
        */
       private static class ChainedTransformer implements Transformer, Serializable {
  -
  +        /** The array of transformers to call */
           private final Transformer[] iTransformers;
   
           /**
  -         * Constructor to store params
  +         * Constructor to store params.
            */
           private ChainedTransformer(Transformer[] transformers) {
               super();
  @@ -768,7 +767,7 @@
           }
   
           /**
  -         * Returns the result of calling a list of transformers
  +         * Returns the result of calling a list of transformers.
            */
           public Object transform(Object object) {
               for (int i = 0; i < iTransformers.length; i++) {
  @@ -785,13 +784,15 @@
        * SwitchTransformer returns the result of the transformer whose predicate returns true.
        */
       private static class SwitchTransformer implements Transformer, Serializable {
  -
  +        /** The array of predicates to switch on */
           private final Predicate[] iPredicates;
  +        /** The array of transformers to call */
           private final Transformer[] iTransformers;
  +        /** The default transformer called if no predicate matches */
           private final Transformer iDefault;
   
           /**
  -         * Constructor to store params
  +         * Constructor to store params.
            */
           private SwitchTransformer(Predicate[] predicates, Transformer[] transformers, Transformer defaultTransformer) {
               super();
  @@ -801,7 +802,7 @@
           }
   
           /**
  -         * Returns the result of the transformer whose predicate returns true
  +         * Returns the result of the transformer whose predicate returns true.
            */
           public Object transform(Object input) {
               for (int i = 0; i < iPredicates.length; i++) {
  @@ -817,15 +818,16 @@
       //----------------------------------------------------------------------------------
   
       /**
  -     * InstantiateTransformer returns the result of calling a Factory.
  +     * InstantiateTransformer returns the result of instantiating the input Class object.
        */
       private static class InstantiateTransformer implements Transformer, Serializable {
  -
  +        /** The array of reflection parameter types */
           private final Class[] iParamTypes;
  +        /** The array of reflection arguments */
           private final Object[] iArgs;
   
           /**
  -         * Constructor to store params
  +         * Constructor to store params.
            */
           private InstantiateTransformer(Class[] paramTypes, Object[] args) {
               super();
  @@ -844,7 +846,7 @@
           }
   
           /**
  -         * Return the result of calling the factory
  +         * Return the result of instantiating the input Class object.
            */
           public Object transform(Object input) {
               try {
  @@ -870,11 +872,11 @@
        * MapTransformer returns the result by looking up in the map.
        */
       private static class MapTransformer implements Transformer, Serializable {
  -
  +        /** The map of data to lookup in */
           private final Map iMap;
   
           /**
  -         * Constructor to store map
  +         * Constructor to store map.
            */
           private MapTransformer(Map map) {
               super();
  @@ -882,7 +884,7 @@
           }
   
           /**
  -         * Returns the result by looking up in the map
  +         * Returns the result by looking up in the map.
            */
           public Object transform(Object input) {
               return iMap.get(input);
  @@ -897,12 +899,15 @@
        * the input object.
        */
       private static class InvokerTransformer implements Transformer, Serializable {
  +        /** The method name to call */
           private final String iMethodName;
  +        /** The array of reflection parameter types */
           private final Class[] iParamTypes;
  +        /** The array of reflection arguments */
           private final Object[] iArgs;
   
           /**
  -         * Constructor
  +         * Constructor.
            */
           public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
               super();
  @@ -926,7 +931,7 @@
           }
   
           /**
  -         * Execute the command based on the input object.
  +         * Invoke the specified method on the input object.
            */
           public Object transform(Object input) {
               if (input == null) {
  
  
  
  1.2       +46 -30    jakarta-commons/lang/src/java/org/apache/commons/lang/functor/PredicateUtils.java
  
  Index: PredicateUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/functor/PredicateUtils.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- PredicateUtils.java	5 Nov 2002 16:44:28 -0000	1.1
  +++ PredicateUtils.java	14 Nov 2002 21:54:49 -0000	1.2
  @@ -64,7 +64,7 @@
   import org.apache.commons.lang.functor.TransformerUtils;
   /**
    * <code>PredicateUtils</code> provides reference implementations and utilities
  - * for the Predicate pattern interface. The supplied predicates are:
  + * for the Predicate functor interface. The supplied predicates are:
    * <ul>
    * <li>Invoker - returns the result of a method call on the input object
    * <li>InstanceOf - true if the object is an instanceof a class
  @@ -127,7 +127,7 @@
        * Gets a Predicate that always throws an exception.
        * This could be useful during testing as a placeholder.
        *
  -     * @return the factory
  +     * @return the predicate
        */
       public static Predicate exceptionPredicate() {
           return EXCEPTION_PREDICATE;
  @@ -199,7 +199,8 @@
       
       /**
        * Creates a Predicate that checks if the object passed in is of
  -     * a particular type, using instanceof.
  +     * a particular type, using instanceof. A <code>null</code> input
  +     * object will return <code>false</code>.
        * 
        * @param type  the type to check for, may not be null
        * @return the predicate
  @@ -207,7 +208,7 @@
        */
       public static Predicate instanceofPredicate(Class type) {
           if (type == null) {
  -            throw new IllegalArgumentException("InstanceofPredicate: The type to check instanceof must not be null");
  +            throw new IllegalArgumentException("The type to check instanceof must not be null");
           }
           return new InstanceofPredicate(type);
       }
  @@ -215,7 +216,9 @@
       /**
        * Creates a Predicate that returns true the first time an object is
        * encoutered, and false if the same object is received 
  -     * again. The comparison is by equals().
  +     * again. The comparison is by equals(). A <code>null</code> input object
  +     * is accepted and will return true the first time, and false subsequently
  +     * as well.
        * 
        * @return the predicate
        */
  @@ -239,6 +242,7 @@
        * @throws IllegalArgumentException if the methodName is null.
        */
       public static Predicate invokerPredicate(String methodName){
  +        // reuse transformer as it has caching - this is lazy really, should have inner class here
           return asPredicate(TransformerUtils.invokerTransformer(methodName));
       }
   
  @@ -260,6 +264,7 @@
        * @throws IllegalArgumentException if the paramTypes and args don't match
        */
       public static Predicate invokerPredicate(String methodName, Class[] paramTypes, Object[] args){
  +        // reuse transformer as it has caching - this is lazy really, should have inner class here
           return asPredicate(TransformerUtils.invokerTransformer(methodName, paramTypes, args));
       }
   
  @@ -272,7 +277,7 @@
        * 
        * @param predicate1  the first predicate, may not be null
        * @param predicate2  the second predicate, may not be null
  -     * @return the predicate
  +     * @return the <code>and</code> predicate
        * @throws IllegalArgumentException if either predicate is null
        */
       public static Predicate andPredicate(Predicate predicate1, Predicate predicate2) {
  @@ -284,7 +289,7 @@
        * predicates are true.
        * 
        * @param predicates  an array of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>all</code> predicate
        * @throws IllegalArgumentException if the predicates array is null
        * @throws IllegalArgumentException if the predicates array has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the array is null
  @@ -298,7 +303,7 @@
        * predicates are true. The predicates are checked in iterator order.
        * 
        * @param predicates  a collection of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>all</code> predicate
        * @throws IllegalArgumentException if the predicates collection is null
        * @throws IllegalArgumentException if the predicates collection has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the collection is null
  @@ -313,7 +318,7 @@
        * 
        * @param predicate1  the first predicate, may not be null
        * @param predicate2  the second predicate, may not be null
  -     * @return the predicate
  +     * @return the <code>or</code> predicate
        * @throws IllegalArgumentException if either predicate is null
        */
       public static Predicate orPredicate(Predicate predicate1, Predicate predicate2) {
  @@ -325,7 +330,7 @@
        * predicates are true.
        * 
        * @param predicates  an array of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>any</code> predicate
        * @throws IllegalArgumentException if the predicates array is null
        * @throws IllegalArgumentException if the predicates array has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the array is null
  @@ -339,7 +344,7 @@
        * predicates are true. The predicates are checked in iterator order.
        * 
        * @param predicates  a collection of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>any</code> predicate
        * @throws IllegalArgumentException if the predicates collection is null
        * @throws IllegalArgumentException if the predicates collection has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the collection is null
  @@ -354,7 +359,7 @@
        * 
        * @param predicate1  the first predicate, may not be null
        * @param predicate2  the second predicate, may not be null
  -     * @return the predicate
  +     * @return the <code>either</code> predicate
        * @throws IllegalArgumentException if either predicate is null
        */
       public static Predicate eitherPredicate(Predicate predicate1, Predicate predicate2) {
  @@ -366,7 +371,7 @@
        * predicates are true.
        * 
        * @param predicates  an array of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>one</code> predicate
        * @throws IllegalArgumentException if the predicates array is null
        * @throws IllegalArgumentException if the predicates array has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the array is null
  @@ -380,7 +385,7 @@
        * predicates are true. The predicates are checked in iterator order.
        * 
        * @param predicates  a collection of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>one</code> predicate
        * @throws IllegalArgumentException if the predicates collection is null
        * @throws IllegalArgumentException if the predicates collection has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the collection is null
  @@ -395,7 +400,7 @@
        * 
        * @param predicate1  the first predicate, may not be null
        * @param predicate2  the second predicate, may not be null
  -     * @return the predicate
  +     * @return the <code>neither</code> predicate
        * @throws IllegalArgumentException if either predicate is null
        */
       public static Predicate neitherPredicate(Predicate predicate1, Predicate predicate2) {
  @@ -407,7 +412,7 @@
        * predicates are true.
        * 
        * @param predicates  an array of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>none</code> predicate
        * @throws IllegalArgumentException if the predicates array is null
        * @throws IllegalArgumentException if the predicates array has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the array is null
  @@ -425,7 +430,7 @@
        * predicates are true. The predicates are checked in iterator order.
        * 
        * @param predicates  a collection of predicates to check, may not be null
  -     * @return the predicate
  +     * @return the <code>none</code> predicate
        * @throws IllegalArgumentException if the predicates collection is null
        * @throws IllegalArgumentException if the predicates collection has less than 2 elements
        * @throws IllegalArgumentException if any predicate in the collection is null
  @@ -443,12 +448,12 @@
        * returns false and vice versa.
        * 
        * @param predicate  the predicate to not
  -     * @return the predicate
  +     * @return the <code>not</code> predicate
        * @throws IllegalArgumentException if the predicate is null
        */
       public static Predicate notPredicate(Predicate predicate) {
           if (predicate == null) {
  -            throw new IllegalArgumentException("NotPredicate: The predicate must not be null");
  +            throw new IllegalArgumentException("The predicate must not be null");
           }
           return new NotPredicate(predicate);
       }
  @@ -462,12 +467,12 @@
        * will be thrown.
        * 
        * @param transformer  the transformer to wrap, may not be null
  -     * @return the predicate
  +     * @return the transformer wrapping predicate
        * @throws IllegalArgumentException if the transformer is null
        */
       public static Predicate asPredicate(Transformer transformer) {
           if (transformer == null) {
  -            throw new IllegalArgumentException("TransformerPredicate: The transformer to call must not be null");
  +            throw new IllegalArgumentException("The transformer to call must not be null");
           }
           return new TransformerPredicate(transformer);
       }
  @@ -531,11 +536,11 @@
        */
       private static Predicate[] validate(Collection predicates) {
           if (predicates == null) {
  -            throw new IllegalArgumentException("PredicateUtils: The predicate collection must not be null");
  +            throw new IllegalArgumentException("The predicate collection must not be null");
           }
           if (predicates.size() < 2) {
               throw new IllegalArgumentException(
  -                "PredicateUtils: At least 2 predicates must be specified in the predicate collection, size was " + predicates.size());
  +                "At least 2 predicates must be specified in the predicate collection, size was " + predicates.size());
           }
           // convert to array like this to guarantee iterator() ordering
           Predicate[] preds = new Predicate[predicates.size()];
  @@ -543,7 +548,7 @@
           for (Iterator it = predicates.iterator(); it.hasNext();) {
               preds[i] = (Predicate) it.next();
               if (preds[i] == null) {
  -                throw new IllegalArgumentException("PredicateUtils: The predicate collection must not contain a null predicate, index " + i + " was null");
  +                throw new IllegalArgumentException("The predicate collection must not contain a null predicate, index " + i + " was null");
               }
               i++;
           }
  @@ -558,16 +563,16 @@
        */
       private static Predicate[] validate(Predicate[] predicates) {
           if (predicates == null) {
  -            throw new IllegalArgumentException("PredicateUtils: The predicate array must not be null");
  +            throw new IllegalArgumentException("The predicate array must not be null");
           }
           if (predicates.length < 2) {
               throw new IllegalArgumentException(
  -                "PredicateUtils: At least 2 predicates must be specified in the predicate array, size was " + predicates.length);
  +                "At least 2 predicates must be specified in the predicate array, size was " + predicates.length);
           }
           Predicate[] preds = new Predicate[predicates.length];
           for (int i = 0; i < predicates.length; i++) {
               if (predicates[i] == null) {
  -                throw new IllegalArgumentException("PredicateUtils: The predicate array must not contain a null predicate, index " + i + " was null");
  +                throw new IllegalArgumentException("The predicate array must not contain a null predicate, index " + i + " was null");
               }
               preds[i] = predicates[i];
           }
  @@ -604,7 +609,7 @@
        * ConstantPredicate returns the same instance each time.
        */
       private static class ConstantPredicate implements Predicate, Serializable {
  -
  +        /** The constant value to return each time */
           private final boolean iConstant;
   
           /**
  @@ -630,6 +635,7 @@
        * AllPredicate returns true if all predicates return true
        */
       private static class AllPredicate implements Predicate, Serializable {
  +        /** The array of predicates to call */
           private final Predicate[] iPredicates;
   
           /**
  @@ -660,6 +666,7 @@
        * AnyPredicate returns true if one of the predicates return true
        */
       private static class AnyPredicate implements Predicate, Serializable {
  +        /** The array of predicates to call */
           private final Predicate[] iPredicates;
   
           /**
  @@ -690,6 +697,7 @@
        * OnePredicate returns true if only one of the predicates return true
        */
       private static class OnePredicate implements Predicate, Serializable {
  +        /** The array of predicates to call */
           private final Predicate[] iPredicates;
   
           /**
  @@ -724,6 +732,7 @@
        * NotPredicate returns the opposite of the wrapped predicate
        */
       private static class NotPredicate implements Predicate, Serializable {
  +        /** The predicate to call */
           private final Predicate iPredicate;
   
           /**
  @@ -749,6 +758,7 @@
        * InstanceofPredicate checks the type of an object
        */
       private static class InstanceofPredicate implements Predicate, Serializable {
  +        /** The type to check for */
           private final Class iType;
   
           /**
  @@ -774,6 +784,7 @@
        * EqualPredicate that checks if the object is a particular value by equals().
        */
       private static class EqualPredicate implements Predicate, Serializable {
  +        /** The object to compare to */
           private final Object iValue;
   
           /**
  @@ -799,6 +810,7 @@
        * IdentityPredicate that checks if the object is a particular value by identity.
        */
       private static class IdentityPredicate implements Predicate, Serializable {
  +        /** The object to compare identity to */
           private final Object iValue;
   
           /**
  @@ -826,6 +838,7 @@
        * again using equals().
        */
       private static class UniquePredicate implements Predicate, Serializable {
  +        /** The set of previously seen objects */
           private final Set iSet = new HashSet();
   
           /**
  @@ -851,7 +864,7 @@
        * TransformerPredicate returns the result of the Transformer as a boolean.
        */
       private static class TransformerPredicate implements Predicate, Serializable {
  -
  +        /** The transformer to call */
           private final Transformer iTransformer;
   
           /**
  @@ -889,6 +902,7 @@
        * NullIsExceptionPredicate returns an exception if null is passed in.
        */
       private static class NullIsExceptionPredicate implements Predicate, Serializable {
  +        /** The predicate to call */
           private final Predicate iPredicate;
           
           /**
  @@ -917,6 +931,7 @@
        * NullIsFalsePredicate returns false if null is passed in.
        */
       private static class NullIsFalsePredicate implements Predicate, Serializable {
  +        /** The predicate to call */
           private final Predicate iPredicate;
           
           /**
  @@ -945,6 +960,7 @@
        * NullIsTruePredicate returns true if null is passed in.
        */
       private static class NullIsTruePredicate implements Predicate, Serializable {
  +        /** The predicate to call */
           private final Predicate iPredicate;
           
           /**
  
  
  
  1.2       +190 -165  jakarta-commons/lang/src/java/org/apache/commons/lang/functor/ExecutorUtils.java
  
  Index: ExecutorUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/functor/ExecutorUtils.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- ExecutorUtils.java	6 Nov 2002 19:15:40 -0000	1.1
  +++ ExecutorUtils.java	14 Nov 2002 21:54:49 -0000	1.2
  @@ -65,20 +65,20 @@
   import org.apache.commons.lang.functor.TransformerUtils;
   /**
    * <code>ExecutorUtils</code> provides reference implementations and utilities
  - * for the Executor pattern interface. The supplied commands are:
  + * for the Executor functor interface. The supplied executors are:
    * <ul>
    * <li>Invoker - invokes a method on the input object
  - * <li>For - repeatedly calls a command for a fixed number of times
  - * <li>While - repeatedly calls a command while a predicate is true
  - * <li>DoWhile - repeatedly calls a command while a predicate is true
  - * <li>Chained - chains two or more commands together
  - * <li>Switch - calls one command based on one or more predicates
  - * <li>SwitchMap - calls one command looked up from a Map
  - * <li>Transformer - wraps a Transformer as a Predicate
  + * <li>For - repeatedly calls an executor for a fixed number of times
  + * <li>While - repeatedly calls an executor while a predicate is true
  + * <li>DoWhile - repeatedly calls an executor while a predicate is true
  + * <li>Chained - chains two or more executors together
  + * <li>Switch - calls one executor based on one or more predicates
  + * <li>SwitchMap - calls one executor looked up from a Map
  + * <li>Transformer - wraps a Transformer as an Executor
    * <li>NOP - does nothing
    * <li>Exception - always throws an exception
    * </ul>
  - * All the supplied commands are Serializable.
  + * All the supplied executors are Serializable.
    *
    * @author <a href="mailto:scolebourne@joda.org">Stephen Colebourne</a>
    * @version $Id$
  @@ -88,11 +88,11 @@
       /**
        * A Executor that always throws an exception
        */
  -    private static final Executor EXCEPTION_COMMAND = new ExceptionExecutor();
  +    private static final Executor EXCEPTION_EXECUTOR = new ExceptionExecutor();
       /**
        * A Executor that does nothing
        */
  -    private static final Executor NOP_COMMAND = new NOPExecutor();
  +    private static final Executor NOP_EXECUTOR = new NOPExecutor();
   
       /**
        * Restrictive constructor
  @@ -105,116 +105,119 @@
        * Gets a Executor that always throws an exception.
        * This could be useful during testing as a placeholder.
        *
  -     * @return the command
  +     * @return the executor
        */
       public static Executor exceptionExecutor() {
  -        return EXCEPTION_COMMAND;
  +        return EXCEPTION_EXECUTOR;
       }
   
       /**
        * Gets a Executor that will do nothing.
        * This could be useful during testing as a placeholder.
        *
  -     * @return the command
  +     * @return the executor
        */
       public static Executor nopExecutor() {
  -        return NOP_COMMAND;
  +        return NOP_EXECUTOR;
       }
   
       /**
  -     * Creates a Executor that calls a Factory each time the transformer is used.
  -     * The transformer will return the value returned by the factory.
  +     * Creates a Executor that calls a Transformer each time it is called.
  +     * The transformer will be called using the executor's input object.
  +     * The transformer's result will be ignored.
        *
  -     * @param transformer  the transformer to run each time in the command
  -     * @return the command.
  +     * @param transformer  the transformer to run each time in the executor
  +     * @return the executor.
        */
       public static Executor asExecutor(Transformer transformer) {
           if (transformer == null) {
  -            throw new IllegalArgumentException("TransformerExecutor: The transformer must not be null");
  +            throw new IllegalArgumentException("The transformer must not be null");
           }
           return new TransformerExecutor(transformer);
       }
   
       /**
  -     * Creates a Executor that will call the command <code>count</code> times.
  +     * Creates a Executor that will call the executor <code>count</code> times.
        *
        * @param count  the number of times to loop
  -     * @param command  the command to call repeatedly
  -     * @return the command
  +     * @param executor  the executor to call repeatedly
  +     * @return the <code>for</code> executor
        * @throws IllegalArgumentException if either argument is null
        */
  -    public static Executor forExecutor(int count, Executor command) {
  +    public static Executor forExecutor(int count, Executor executor) {
           if (count < 0) {
  -            throw new IllegalArgumentException("ForExecutor: The loop count must not be less than zero, it was " + count);
  +            throw new IllegalArgumentException("The loop count must not be less than zero, it was " + count);
           }
  -        if (command == null) {
  -            throw new IllegalArgumentException("ForExecutor: The command must not be null");
  +        if (executor == null) {
  +            throw new IllegalArgumentException("The executor must not be null");
           }
  -        return new ForExecutor(count, command);
  +        return new ForExecutor(count, executor);
       }
   
       /**
  -     * Creates a Executor that will call the command repeatedly until the 
  +     * Creates a Executor that will call the executor repeatedly until the 
        * predicate returns false.
        *
        * @param predicate  the predicate to use as an end of loop test
  -     * @param command  the command to call repeatedly
  -     * @return the command
  +     * @param executor  the executor to call repeatedly
  +     * @return the <code>while</code> executor
        * @throws IllegalArgumentException if either argument is null
        */
  -    public static Executor whileExecutor(Predicate predicate, Executor command) {
  +    public static Executor whileExecutor(Predicate predicate, Executor executor) {
           if (predicate == null) {
  -            throw new IllegalArgumentException("WhileExecutor: The predicate must not be null");
  +            throw new IllegalArgumentException("The predicate must not be null");
           }
  -        if (command == null) {
  -            throw new IllegalArgumentException("WhileExecutor: The command must not be null");
  +        if (executor == null) {
  +            throw new IllegalArgumentException("The executor must not be null");
           }
  -        return new WhileExecutor(predicate, command, false);
  +        return new WhileExecutor(predicate, executor, false);
       }
   
       /**
  -     * Creates a Executor that will call the command once and then repeatedly
  +     * Creates a Executor that will call the executor once and then repeatedly
        * until the predicate returns false.
        *
  -     * @param command  the command to call repeatedly
  +     * @param executor  the executor to call repeatedly
        * @param predicate  the predicate to use as an end of loop test
  -     * @return the command
  +     * @return the <code>do-while</code> executor
        * @throws IllegalArgumentException if either argument is null
        */
  -    public static Executor doWhileExecutor(Executor command, Predicate predicate) {
  -        if (command == null) {
  -            throw new IllegalArgumentException("DoWhileExecutor: The command must not be null");
  +    public static Executor doWhileExecutor(Executor executor, Predicate predicate) {
  +        if (executor == null) {
  +            throw new IllegalArgumentException("The executor must not be null");
           }
           if (predicate == null) {
  -            throw new IllegalArgumentException("DoWhileExecutor: The predicate must not be null");
  +            throw new IllegalArgumentException("The predicate must not be null");
           }
  -        return new WhileExecutor(predicate, command, true);
  +        return new WhileExecutor(predicate, executor, true);
       }
   
       /**
  -     * Creates a Executor that will invoke a specific method on the command's
  +     * Creates a Executor that will invoke a specific method on the executor's
        * input object by reflection.
        *
        * @param methodName  the name of the method
  -     * @return the command
  +     * @return the <code>invoker</code> executor
        * @throws IllegalArgumentException if the method name is null
        */
       public static Executor invokerExecutor(String methodName) {
  +        // reuse transformer as it has caching - this is lazy really, should have inner class here
           return asExecutor(TransformerUtils.invokerTransformer(methodName, null, null));
       }
   
       /**
  -     * Creates a Executor that will invoke a specific method on the command's
  +     * Creates a Executor that will invoke a specific method on the executor's
        * input object by reflection.
        *
        * @param methodName  the name of the method
        * @param paramTypes  the parameter types
        * @param args  the arguments
  -     * @return the command
  +     * @return the <code>invoker</code> executor
        * @throws IllegalArgumentException if the method name is null
        * @throws IllegalArgumentException if the paramTypes and args don't match
        */
       public static Executor invokerExecutor(String methodName, Class[] paramTypes, Object[] args) {
  +        // reuse transformer as it has caching - this is lazy really, should have inner class here
           return asExecutor(TransformerUtils.invokerTransformer(methodName, paramTypes, args));
       }
   
  @@ -222,52 +225,52 @@
        * Create a new Executor that calls two Executors, passing the result of
        * the first into the second.
        * 
  -     * @param command1  the first command
  -     * @param command2  the second command
  -     * @return the command
  -     * @throws IllegalArgumentException if either command is null
  +     * @param executor1  the first executor
  +     * @param executor2  the second executor
  +     * @return the <code>chained</code> executor
  +     * @throws IllegalArgumentException if either executor is null
        */
  -    public static Executor chainedExecutor(Executor command1, Executor command2) {
  -        Executor[] commands = new Executor[] { command1, command2 };
  -        validate(commands);
  -        return new ChainedExecutor(commands);
  +    public static Executor chainedExecutor(Executor executor1, Executor executor2) {
  +        Executor[] executors = new Executor[] { executor1, executor2 };
  +        validate(executors);
  +        return new ChainedExecutor(executors);
       }
   
       /**
  -     * Create a new Executor that calls each command in turn, passing the 
  -     * result into the next command.
  +     * Create a new Executor that calls each executor in turn, passing the 
  +     * result into the next executor.
        * 
  -     * @param commands  an array of commands to chain
  -     * @return the command
  -     * @throws IllegalArgumentException if the commands array is null
  -     * @throws IllegalArgumentException if the commands array has 0 elements
  -     * @throws IllegalArgumentException if any command in the array is null
  +     * @param executors  an array of executors to chain
  +     * @return the <code>chained</code> executor
  +     * @throws IllegalArgumentException if the executors array is null
  +     * @throws IllegalArgumentException if the executors array has 0 elements
  +     * @throws IllegalArgumentException if any executor in the array is null
        */
  -    public static Executor chainedExecutor(Executor[] commands) {
  -        commands = copy(commands);
  -        validate(commands);
  -        return new ChainedExecutor(commands);
  +    public static Executor chainedExecutor(Executor[] executors) {
  +        executors = copy(executors);
  +        validate(executors);
  +        return new ChainedExecutor(executors);
       }
   
       /**
  -     * Create a new Executor that calls each command in turn, passing the 
  -     * result into the next command. The ordering is that of the iterator()
  +     * Create a new Executor that calls each executor in turn, passing the 
  +     * result into the next executor. The ordering is that of the iterator()
        * method on the collection.
        * 
  -     * @param commands  a collection of commands to chain
  -     * @return the command
  -     * @throws IllegalArgumentException if the commands collection is null
  -     * @throws IllegalArgumentException if the commands collection is empty
  -     * @throws IllegalArgumentException if any command in the collection is null
  -     */
  -    public static Executor chainedExecutor(Collection commands) {
  -        if (commands == null) {
  -            throw new IllegalArgumentException("ChainedExecutor: The command collection must not be null");
  +     * @param executors  a collection of executors to chain
  +     * @return the <code>chained</code> executor
  +     * @throws IllegalArgumentException if the executors collection is null
  +     * @throws IllegalArgumentException if the executors collection is empty
  +     * @throws IllegalArgumentException if any executor in the collection is null
  +     */
  +    public static Executor chainedExecutor(Collection executors) {
  +        if (executors == null) {
  +            throw new IllegalArgumentException("The executor collection must not be null");
           }
           // convert to array like this to guarantee iterator() ordering
  -        Executor[] cmds = new Executor[commands.size()];
  +        Executor[] cmds = new Executor[executors.size()];
           int i = 0;
  -        for (Iterator it = commands.iterator(); it.hasNext();) {
  +        for (Iterator it = executors.iterator(); it.hasNext();) {
               cmds[i++] = (Executor) it.next();
           }
           validate(cmds);
  @@ -275,81 +278,85 @@
       }
   
       /**
  -     * Create a new Executor that calls one of two commands depending 
  +     * Create a new Executor that calls one of two executors depending 
        * on the specified predicate.
        * 
        * @param predicate  the predicate to switch on
  -     * @param trueExecutor  the command called if the predicate is true
  -     * @param falseExecutor  the command called if the predicate is false
  -     * @return the command
  +     * @param trueExecutor  the executor called if the predicate is true
  +     * @param falseExecutor  the executor called if the predicate is false
  +     * @return the <code>switch</code> executor
        * @throws IllegalArgumentException if the predicate is null
  -     * @throws IllegalArgumentException if either command is null
  +     * @throws IllegalArgumentException if either executor is null
        */
       public static Executor switchExecutor(Predicate predicate, Executor trueExecutor, Executor falseExecutor) {
           return switchExecutorInternal(new Predicate[] { predicate }, new Executor[] { trueExecutor }, falseExecutor);
       }
   
       /**
  -     * Create a new Executor that calls one of the commands depending 
  -     * on the predicates. The command at array location 0 is called if the
  -     * predicate at array location 0 returned true. Each predicate is evaluated
  +     * Create a new Executor that calls one of the executors depending 
  +     * on the predicates.
  +     * <p>
  +     * The executor at array location 0 is called if the predicate at array 
  +     * location 0 returned true. Each predicate is evaluated
        * until one returns true.
        * 
        * @param predicates  an array of predicates to check
  -     * @param commands  an array of commands to call
  -     * @return the command
  +     * @param executors  an array of executors to call
  +     * @return the <code>switch</code> executor
        * @throws IllegalArgumentException if the either array is null
        * @throws IllegalArgumentException if the either array has 0 elements
        * @throws IllegalArgumentException if any element in the arrays is null
        * @throws IllegalArgumentException if the arrays are different sizes
        */
  -    public static Executor switchExecutor(Predicate[] predicates, Executor[] commands) {
  -        return switchExecutorInternal(copy(predicates), copy(commands), null);
  +    public static Executor switchExecutor(Predicate[] predicates, Executor[] executors) {
  +        return switchExecutorInternal(copy(predicates), copy(executors), null);
       }
   
       /**
  -     * Create a new Executor that calls one of the commands depending 
  -     * on the predicates. The command at array location 0 is called if the
  -     * predicate at array location 0 returned true. Each predicate is evaluated
  +     * Create a new Executor that calls one of the executors depending 
  +     * on the predicates.
  +     * <p>
  +     * The executor at array location 0 is called if the predicate at array
  +     * location 0 returned true. Each predicate is evaluated
        * until one returns true. If no predicates evaluate to true, the default
  -     * command is called.
  +     * executor is called.
        * 
        * @param predicates  an array of predicates to check
  -     * @param commands  an array of commands to call
  +     * @param executors  an array of executors to call
        * @param defaultExecutor  the default to call if no predicate matches
  -     * @return the command
  +     * @return the <code>switch</code> executor
        * @throws IllegalArgumentException if the either array is null
        * @throws IllegalArgumentException if the either array has 0 elements
        * @throws IllegalArgumentException if any element in the arrays is null
        * @throws IllegalArgumentException if the arrays are different sizes
        */
  -    public static Executor switchExecutor(Predicate[] predicates, Executor[] commands, Executor defaultExecutor) {
  -        return switchExecutorInternal(copy(predicates), copy(commands), defaultExecutor);
  +    public static Executor switchExecutor(Predicate[] predicates, Executor[] executors, Executor defaultExecutor) {
  +        return switchExecutorInternal(copy(predicates), copy(executors), defaultExecutor);
       }
       
       /**
  -     * Create a new Executor that calls one of the commands depending 
  +     * Create a new Executor that calls one of the executors depending 
        * on the predicates. 
        * <p>
  -     * The Map consists of Predicate keys and Executor values. A command 
  +     * The Map consists of Predicate keys and Executor values. A executor 
        * is called if its matching predicate returns true. Each predicate is evaluated
        * until one returns true. If no predicates evaluate to true, the default
  -     * command is called. The default command is set in the map with a 
  +     * executor is called. The default executor is set in the map with a 
        * null key. The ordering is that of the iterator() method on the entryset 
        * collection of the map.
        * 
  -     * @param predicatesAndExecutors  a map of predicates to commands
  -     * @return the command
  +     * @param predicatesAndExecutors  a map of predicates to executors
  +     * @return the <code>switch</code> executor
        * @throws IllegalArgumentException if the map is null
        * @throws IllegalArgumentException if the map is empty
  -     * @throws IllegalArgumentException if any command in the map is null
  +     * @throws IllegalArgumentException if any executor in the map is null
        * @throws ClassCastException  if the map elements are of the wrong type
        */
       public static Executor switchExecutor(Map predicatesAndExecutors) {
           Executor[] trs = null;
           Predicate[] preds = null;
           if (predicatesAndExecutors == null) {
  -            throw new IllegalArgumentException("SwitchExecutor: The predicate and command map must not be null");
  +            throw new IllegalArgumentException("The predicate and executor map must not be null");
           }
           // convert to array like this to guarantee iterator() ordering
           Executor def = (Executor) predicatesAndExecutors.remove(null);
  @@ -367,40 +374,49 @@
       }
   
       /**
  -     * Validate input and create command
  +     * Validate input and create executor.
  +     * 
  +     * @param predicates  an array of predicates to check
  +     * @param executors  an array of executors to call
  +     * @param defaultExecutor  the default to call if no predicate matches
  +     * @return the <code>switch</code> executor
  +     * @throws IllegalArgumentException if the either array is null
  +     * @throws IllegalArgumentException if the either array has 0 elements
  +     * @throws IllegalArgumentException if any element in the arrays is null
  +     * @throws IllegalArgumentException if the arrays are different sizes
        */
  -    private static Executor switchExecutorInternal(Predicate[] predicates, Executor[] commands, Executor defaultExecutor) {
  +    private static Executor switchExecutorInternal(Predicate[] predicates, Executor[] executors, Executor defaultExecutor) {
           validate(predicates);
  -        validate(commands);
  -        if (predicates.length != commands.length) {
  -            throw new IllegalArgumentException("SwitchExecutor: The predicate and command arrays must be the same size");
  +        validate(executors);
  +        if (predicates.length != executors.length) {
  +            throw new IllegalArgumentException("The predicate and executor arrays must be the same size");
           }
           if (defaultExecutor == null) {
               defaultExecutor = nopExecutor();
           }
  -        return new SwitchExecutor(predicates, commands, defaultExecutor);
  +        return new SwitchExecutor(predicates, executors, defaultExecutor);
       }
   
       /**
        * Create a new Executor that uses the input object as a key to find the
  -     * command to call. 
  +     * executor to call. 
        * <p>
  -     * The Map consists of object keys and Executor values. A command 
  +     * The Map consists of object keys and Executor values. A executor 
        * is called if the input object equals the key. If there is no match, the
  -     * default command is called. The default command is set in the map
  +     * default executor is called. The default executor is set in the map
        * using a null key.
        * 
  -     * @param objectsAndExecutors  a map of objects to commands
  -     * @return the command
  +     * @param objectsAndExecutors  a map of objects to executors
  +     * @return the executor
        * @throws IllegalArgumentException if the map is null
        * @throws IllegalArgumentException if the map is empty
  -     * @throws IllegalArgumentException if any command in the map is null
  +     * @throws IllegalArgumentException if any executor in the map is null
        */
       public static Executor switchMapExecutor(Map objectsAndExecutors) {
           Executor[] trs = null;
           Predicate[] preds = null;
           if (objectsAndExecutors == null) {
  -            throw new IllegalArgumentException("SwitchEqualsExecutor: The obejct and command map must not be null");
  +            throw new IllegalArgumentException("The obejct and executor map must not be null");
           }
           Executor def = (Executor) objectsAndExecutors.remove(null);
           int size = objectsAndExecutors.size();
  @@ -417,9 +433,10 @@
       }
   
       /**
  -     * Copy method
  +     * Clone the predicates to ensure that the internal reference can't be messed with.
        * 
        * @param predicates  the predicates to copy
  +     * @return the cloned predicates
        */
       private static Predicate[] copy(Predicate[] predicates) {
           if (predicates == null) {
  @@ -429,53 +446,56 @@
       }
       
       /**
  -     * Validate method
  +     * Validate the predicates to ensure that all is well.
        * 
        * @param predicates  the predicates to validate
  +     * @return the validated predicates
        */
       private static void validate(Predicate[] predicates) {
           if (predicates == null) {
  -            throw new IllegalArgumentException("ExecutorUtils: The predicate array must not be null");
  +            throw new IllegalArgumentException("The predicate array must not be null");
           }
           if (predicates.length < 1) {
               throw new IllegalArgumentException(
  -                "ExecutorUtils: At least 1 predicate must be specified in the predicate array, size was " + predicates.length);
  +                "At least 1 predicate must be specified in the predicate array, size was " + predicates.length);
           }
           for (int i = 0; i < predicates.length; i++) {
               if (predicates[i] == null) {
  -                throw new IllegalArgumentException("ExecutorUtils: The predicate array must not contain a null predicate, index " + i + " was null");
  +                throw new IllegalArgumentException("The predicate array must not contain a null predicate, index " + i + " was null");
               }
           }
       }
   
       /**
  -     * Copy method
  +     * Clone the executors to ensure that the internal reference can't be messed with.
        * 
  -     * @param commands  the commands to copy
  +     * @param executors  the executors to copy
  +     * @return the cloned executors
        */
  -    private static Executor[] copy(Executor[] commands) {
  -        if (commands == null) {
  +    private static Executor[] copy(Executor[] executors) {
  +        if (executors == null) {
               return null;
           }
  -        return (Executor[]) commands.clone();
  +        return (Executor[]) executors.clone();
       }
       
       /**
  -     * Validate method
  +     * Validate the executors to ensure that all is well.
        * 
  -     * @param commands  the commands to validate
  +     * @param executors  the executors to validate
  +     * @return the validated executors
        */
  -    private static void validate(Executor[] commands) {
  -        if (commands == null) {
  -            throw new IllegalArgumentException("ExecutorUtils: The command array must not be null");
  +    private static void validate(Executor[] executors) {
  +        if (executors == null) {
  +            throw new IllegalArgumentException("The executor array must not be null");
           }
  -        if (commands.length < 1) {
  +        if (executors.length < 1) {
               throw new IllegalArgumentException(
  -                "ExecutorUtils: At least 1 command must be specified in the command array, size was " + commands.length);
  +                "At least 1 executor must be specified in the executor array, size was " + executors.length);
           }
  -        for (int i = 0; i < commands.length; i++) {
  -            if (commands[i] == null) {
  -                throw new IllegalArgumentException("ExecutorUtils: The command array must not contain a null command, index " + i + " was null");
  +        for (int i = 0; i < executors.length; i++) {
  +            if (executors[i] == null) {
  +                throw new IllegalArgumentException("The executor array must not contain a null executor, index " + i + " was null");
               }
           }
       }
  @@ -530,14 +550,14 @@
       //----------------------------------------------------------------------------------
   
       /**
  -     * TransformerExecutor returns the result of calling a Transformer.
  +     * TransformerExecutor calls a Transformer using the input object and ignore the result.
        */
       private static class TransformerExecutor implements Executor, Serializable {
  -
  +        /** The transformer to wrap */
           private final Transformer iTransformer;
   
           /**
  -         * Constructor to store factory
  +         * Constructor to store transformer
            */
           private TransformerExecutor(Transformer transformer) {
               super();
  @@ -545,7 +565,7 @@
           }
   
           /**
  -         * Return the result of calling the factory
  +         * Call the transformer
            */
           public void execute(Object input) {
               try {
  @@ -561,22 +581,22 @@
       //----------------------------------------------------------------------------------
   
       /**
  -     * ChainedExecutor calls a list of commands.
  +     * ChainedExecutor calls a list of executors.
        */
       private static class ChainedExecutor implements Executor, Serializable {
  -
  +        /** The executors to call in turn */
           private final Executor[] iExecutors;
   
           /**
            * Constructor to store params
            */
  -        private ChainedExecutor(Executor[] commands) {
  +        private ChainedExecutor(Executor[] executors) {
               super();
  -            iExecutors = commands;
  +            iExecutors = executors;
           }
   
           /**
  -         * Execute a list of commands
  +         * Execute a list of executors
            */
           public void execute(Object input) {
               for (int i = 0; i < iExecutors.length; i++) {
  @@ -589,26 +609,28 @@
       //----------------------------------------------------------------------------------
   
       /**
  -     * SwitchExecutor calls the command whose predicate returns true.
  +     * SwitchExecutor calls the executor whose predicate returns true.
        */
       private static class SwitchExecutor implements Executor, Serializable {
  -
  +        /** The tests to consider */
           private final Predicate[] iPredicates;
  +        /** The matching executors to call */
           private final Executor[] iExecutors;
  +        /** The default executor to call if no tests match */
           private final Executor iDefault;
   
           /**
            * Constructor to store params
            */
  -        private SwitchExecutor(Predicate[] predicates, Executor[] commands, Executor defaultExecutor) {
  +        private SwitchExecutor(Predicate[] predicates, Executor[] executors, Executor defaultExecutor) {
               super();
               iPredicates = predicates;
  -            iExecutors = commands;
  +            iExecutors = executors;
               iDefault = defaultExecutor;
           }
   
           /**
  -         * Execute the command whose predicate returns true
  +         * Execute the executor whose predicate returns true
            */
           public void execute(Object input) {
               for (int i = 0; i < iPredicates.length; i++) {
  @@ -625,24 +647,25 @@
       //----------------------------------------------------------------------------------
   
       /**
  -     * ForExecutor calls the command a fixed nunmber of times.
  +     * ForExecutor calls the executor a fixed nunmber of times.
        */
       private static class ForExecutor implements Executor, Serializable {
  -
  +        /** The number of times to loop */
           private final int iCount;
  +        /** The executor to call */
           private final Executor iExecutor;
   
           /**
            * Constructor to store params
            */
  -        private ForExecutor(int count, Executor command) {
  +        private ForExecutor(int count, Executor executor) {
               super();
               iCount = count;
  -            iExecutor = command;
  +            iExecutor = executor;
           }
   
           /**
  -         * Execute the command count times
  +         * Execute the executor count times
            */
           public void execute(Object input) {
               for (int i = 0; i < iCount; i++) {
  @@ -655,26 +678,28 @@
       //----------------------------------------------------------------------------------
   
       /**
  -     * WhileExecutor calls the command until the predicate is false.
  +     * WhileExecutor calls the executor until the predicate is false.
        */
       private static class WhileExecutor implements Executor, Serializable {
  -
  +        /** The test condition */
           private final Predicate iPredicate;
  +        /** The executor to call */
           private final Executor iExecutor;
  +        /** The flag, true is a do loop, false is a while */
           private final boolean iDoLoop;
   
           /**
            * Constructor to store params
            */
  -        private WhileExecutor(Predicate predicate, Executor command, boolean doLoop) {
  +        private WhileExecutor(Predicate predicate, Executor executor, boolean doLoop) {
               super();
               iPredicate = predicate;
  -            iExecutor = command;
  +            iExecutor = executor;
               iDoLoop = doLoop;
           }
   
           /**
  -         * Execute the command until the predicate is false
  +         * Execute the executor until the predicate is false
            */
           public void execute(Object input) {
               if (iDoLoop) {
  
  
  

--
To unsubscribe, e-mail:   <mailto:commons-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:commons-dev-help@jakarta.apache.org>


Mime
View raw message