Initial addition into subversion with build script changes

git-svn-id: file:///home/sven/projects/JOGL/temp/ant-contrib/svn/ant-contrib-code/trunk/ant-contrib@5 32d7a393-a5a9-423c-abd3-5d954feb1f2f

1 files changed, 433 insertions, 0 deletions

diff --git a/src/java/net/sf/antcontrib/logic/ForTask.java b/src/java/net/sf/antcontrib/logic/ForTask.java
new file mode 100644
index 0000000..516773b
--- /dev/null
+++ b/src/java/net/sf/antcontrib/logic/ForTask.java
@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) 2003-2005 Ant-Contrib project.  All rights reserved.
+ *
+ * Licensed 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 net.sf.antcontrib.logic;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.Task;
+import org.apache.tools.ant.taskdefs.MacroDef;
+import org.apache.tools.ant.taskdefs.MacroInstance;
+import org.apache.tools.ant.taskdefs.Parallel;
+import org.apache.tools.ant.types.DirSet;
+import org.apache.tools.ant.types.FileSet;
+import org.apache.tools.ant.types.Path;
+
+/***
+ * Task definition for the for task.  This is based on
+ * the foreach task but takes a sequential element
+ * instead of a target and only works for ant >= 1.6Beta3
+ * @author Peter Reilly
+ */
+public class ForTask extends Task {
+
+    private String     list;
+    private String     param;
+    private String     delimiter = ",";
+    private Path       currPath;
+    private boolean    trim;
+    private boolean    keepgoing = false;
+    private MacroDef   macroDef;
+    private List       hasIterators = new ArrayList();
+    private boolean    parallel = false;
+    private Integer    threadCount;
+    private Parallel   parallelTasks;
+
+    /**
+     * Creates a new <code>For</code> instance.
+     * This checks if the ant version is correct to run this task.
+     */
+    public ForTask() {
+    }
+
+    /**
+     * Attribute whether to execute the loop in parallel or in sequence.
+     * @param parallel if true execute the tasks in parallel. Default is false.
+     */
+    public void setParallel(boolean parallel) {
+        this.parallel = parallel;
+    }
+
+    /***
+     * Set the maximum amount of threads we're going to allow
+     * to execute in parallel
+     * @param threadCount the number of threads to use
+     */
+    public void setThreadCount(int threadCount) {
+        if (threadCount < 1) {
+            throw new BuildException("Illegal value for threadCount " + threadCount
+                                     + " it should be > 0");
+        }
+        this.threadCount = new Integer(threadCount);
+    }
+
+    /**
+     * Set the trim attribute.
+     *
+     * @param trim if true, trim the value for each iterator.
+     */
+    public void setTrim(boolean trim) {
+        this.trim = trim;
+    }
+
+    /**
+     * Set the keepgoing attribute, indicating whether we
+     * should stop on errors or continue heedlessly onward.
+     *
+     * @param keepgoing a boolean, if <code>true</code> then we act in
+     * the keepgoing manner described.
+     */
+    public void setKeepgoing(boolean keepgoing) {
+        this.keepgoing = keepgoing;
+    }
+
+    /**
+     * Set the list attribute.
+     *
+     * @param list a list of delimiter separated tokens.
+     */
+    public void setList(String list) {
+        this.list = list;
+    }
+
+    /**
+     * Set the delimiter attribute.
+     *
+     * @param delimiter the delimiter used to separate the tokens in
+     *        the list attribute. The default is ",".
+     */
+    public void setDelimiter(String delimiter) {
+        this.delimiter = delimiter;
+    }
+
+    /**
+     * Set the param attribute.
+     * This is the name of the macrodef attribute that
+     * gets set for each iterator of the sequential element.
+     *
+     * @param param the name of the macrodef attribute.
+     */
+    public void setParam(String param) {
+        this.param = param;
+    }
+
+    private Path getOrCreatePath() {
+        if (currPath == null) {
+            currPath = new Path(getProject());
+        }
+        return currPath;
+    }
+
+    /**
+     * This is a path that can be used instread of the list
+     * attribute to interate over. If this is set, each
+     * path element in the path is used for an interator of the
+     * sequential element.
+     *
+     * @param path the path to be set by the ant script.
+     */
+    public void addConfigured(Path path) {
+        getOrCreatePath().append(path);
+    }
+
+    /**
+     * This is a path that can be used instread of the list
+     * attribute to interate over. If this is set, each
+     * path element in the path is used for an interator of the
+     * sequential element.
+     *
+     * @param path the path to be set by the ant script.
+     */
+    public void addConfiguredPath(Path path) {
+        addConfigured(path);
+    }
+
+    /**
+     * @return a MacroDef#NestedSequential object to be configured
+     */
+    public Object createSequential() {
+        macroDef = new MacroDef();
+        macroDef.setProject(getProject());
+        return macroDef.createSequential();
+    }
+
+    /**
+     * Run the for task.
+     * This checks the attributes and nested elements, and
+     * if there are ok, it calls doTheTasks()
+     * which constructes a macrodef task and a
+     * for each interation a macrodef instance.
+     */
+    public void execute() {
+        if (parallel) {
+            parallelTasks = (Parallel) getProject().createTask("parallel");
+            if (threadCount != null) {
+                parallelTasks.setThreadCount(threadCount.intValue());
+            }
+        }
+        if (list == null && currPath == null && hasIterators.size() == 0) {
+            throw new BuildException(
+                "You must have a list or path to iterate through");
+        }
+        if (param == null) {
+            throw new BuildException(
+                "You must supply a property name to set on"
+                + " each iteration in param");
+        }
+        if (macroDef == null) {
+            throw new BuildException(
+                "You must supply an embedded sequential "
+                + "to perform");
+        }
+        doTheTasks();
+        if (parallel) {
+            parallelTasks.perform();
+        }
+    }
+
+
+    private void doSequentialIteration(String val) {
+        MacroInstance instance = new MacroInstance();
+        instance.setProject(getProject());
+        instance.setOwningTarget(getOwningTarget());
+        instance.setMacroDef(macroDef);
+        instance.setDynamicAttribute(param.toLowerCase(),
+                                     val);
+        if (!parallel) {
+            instance.execute();
+        } else {
+            parallelTasks.addTask(instance);
+        }
+    }
+
+    private void doTheTasks() {
+        int errorCount = 0;
+        int taskCount = 0;
+
+        // Create a macro attribute
+        MacroDef.Attribute attribute = new MacroDef.Attribute();
+        attribute.setName(param);
+        macroDef.addConfiguredAttribute(attribute);
+        // Take Care of the list attribute
+        if (list != null) {
+            StringTokenizer st = new StringTokenizer(list, delimiter);
+
+            while (st.hasMoreTokens()) {
+                String tok = st.nextToken();
+                if (trim) {
+                    tok = tok.trim();
+                }
+                try {
+                    taskCount++;
+                    doSequentialIteration(tok);
+                } catch (BuildException bx) {
+                    if (keepgoing) {
+                        log(tok + ": " + bx.getMessage(), Project.MSG_ERR);
+                        errorCount++;
+                    } else {
+                        throw bx;
+                    }
+                }
+            }
+        }
+        if (keepgoing && (errorCount != 0)) {
+            throw new BuildException(
+                "Keepgoing execution: " + errorCount
+                + " of " + taskCount + " iterations failed.");
+        }
+
+        // Take Care of the path element
+        String[] pathElements = new String[0];
+        if (currPath != null) {
+            pathElements = currPath.list();
+        }
+        for (int i = 0; i < pathElements.length; i++) {
+            File nextFile = new File(pathElements[i]);
+            try {
+                taskCount++;
+                doSequentialIteration(nextFile.getAbsolutePath());
+            } catch (BuildException bx) {
+                if (keepgoing) {
+                	log(nextFile + ": " + bx.getMessage(), Project.MSG_ERR);
+                    errorCount++;
+                } else {
+                    throw bx;
+                }
+            }
+        }
+        if (keepgoing && (errorCount != 0)) {
+            throw new BuildException(
+                "Keepgoing execution: " + errorCount
+                + " of " + taskCount + " iterations failed.");
+        }
+
+        // Take care of iterators
+        for (Iterator i = hasIterators.iterator(); i.hasNext();) {
+            Iterator it = ((HasIterator) i.next()).iterator();
+            while (it.hasNext()) {
+            	String s = it.next().toString();
+                try {
+                    taskCount++;
+                    doSequentialIteration(s);
+                } catch (BuildException bx) {
+                    if (keepgoing) {
+                    	log(s + ": " + bx.getMessage(), Project.MSG_ERR);
+                        errorCount++;
+                    } else {
+                        throw bx;
+                    }
+                }
+            }
+        }
+        if (keepgoing && (errorCount != 0)) {
+            throw new BuildException(
+                "Keepgoing execution: " + errorCount
+                + " of " + taskCount + " iterations failed.");
+        }
+    }
+
+    /**
+     * Add a Map, iterate over the values
+     *
+     * @param map a Map object - iterate over the values.
+     */
+    public void add(Map map) {
+        hasIterators.add(new MapIterator(map));
+    }
+
+    /**
+     * Add a fileset to be iterated over.
+     *
+     * @param fileset a <code>FileSet</code> value
+     */
+    public void add(FileSet fileset) {
+        getOrCreatePath().addFileset(fileset);
+    }
+
+    /**
+     * Add a fileset to be iterated over.
+     *
+     * @param fileset a <code>FileSet</code> value
+     */
+    public void addFileSet(FileSet fileset) {
+        add(fileset);
+    }
+
+    /**
+     * Add a dirset to be iterated over.
+     *
+     * @param dirset a <code>DirSet</code> value
+     */
+    public void add(DirSet dirset) {
+        getOrCreatePath().addDirset(dirset);
+    }
+
+    /**
+     * Add a dirset to be iterated over.
+     *
+     * @param dirset a <code>DirSet</code> value
+     */
+    public void addDirSet(DirSet dirset) {
+        add(dirset);
+    }
+
+    /**
+     * Add a collection that can be iterated over.
+     *
+     * @param collection a <code>Collection</code> value.
+     */
+    public void add(Collection collection) {
+        hasIterators.add(new ReflectIterator(collection));
+    }
+
+    /**
+     * Add an iterator to be iterated over.
+     *
+     * @param iterator an <code>Iterator</code> value
+     */
+    public void add(Iterator iterator) {
+        hasIterators.add(new IteratorIterator(iterator));
+    }
+
+    /**
+     * Add an object that has an Iterator iterator() method
+     * that can be iterated over.
+     *
+     * @param obj An object that can be iterated over.
+     */
+    public void add(Object obj) {
+        hasIterators.add(new ReflectIterator(obj));
+    }
+
+    /**
+     * Interface for the objects in the iterator collection.
+     */
+    private interface HasIterator {
+        Iterator iterator();
+    }
+
+    private static class IteratorIterator implements HasIterator {
+        private Iterator iterator;
+        public IteratorIterator(Iterator iterator) {
+            this.iterator = iterator;
+        }
+        public Iterator iterator() {
+            return this.iterator;
+        }
+    }
+
+    private static class MapIterator implements HasIterator {
+        private Map map;
+        public MapIterator(Map map) {
+            this.map = map;
+        }
+        public Iterator iterator() {
+            return map.values().iterator();
+        }
+    }
+
+    private static class ReflectIterator implements HasIterator {
+        private Object  obj;
+        private Method  method;
+        public ReflectIterator(Object obj) {
+            this.obj = obj;
+            try {
+                method = obj.getClass().getMethod(
+                    "iterator", new Class[] {});
+            } catch (Throwable t) {
+                throw new BuildException(
+                    "Invalid type " + obj.getClass() + " used in For task, it does"
+                    + " not have a public iterator method");
+            }
+        }
+
+        public Iterator iterator() {
+            try {
+                return (Iterator) method.invoke(obj, new Object[] {});
+            } catch (Throwable t) {
+                throw new BuildException(t);
+            }
+        }
+    }
+}