+ * This class also encapsulates methods which allow files to be referred
+ * to using abstract path names which are translated to native system
+ * file paths at runtime.
+ *
+ * @author duncan@x180.com
+ *
+ * @version $Revision$
+ */
+
+public class Project {
+
+ /** Message priority of "error". */
+ public final static int MSG_ERR = 0;
+ /** Message priority of "warning". */
+ public final static int MSG_WARN = 1;
+ /** Message priority of "information". */
+ public final static int MSG_INFO = 2;
+ /** Message priority of "verbose". */
+ public final static int MSG_VERBOSE = 3;
+ /** Message priority of "debug". */
+ public final static int MSG_DEBUG = 4;
+
+ /**
+ * Constant for the "visiting" state, used when
+ * traversing a DFS of target dependencies.
+ */
+ private final static String VISITING = "VISITING";
+ /**
+ * Constant for the "visited" state, used when
+ * traversing a DFS of target dependencies.
+ */
+ private final static String VISITED = "VISITED";
+
+ /** Version of currently running VM. */
+ private static String javaVersion;
+
+ /** Version constant for Java 1.0 */
+ public final static String JAVA_1_0 = "1.0";
+ /** Version constant for Java 1.1 */
+ public final static String JAVA_1_1 = "1.1";
+ /** Version constant for Java 1.2 */
+ public final static String JAVA_1_2 = "1.2";
+ /** Version constant for Java 1.3 */
+ public final static String JAVA_1_3 = "1.3";
+ /** Version constant for Java 1.4 */
+ public final static String JAVA_1_4 = "1.4";
+
+ /** Default filter start token. */
+ public final static String TOKEN_START = FilterSet.DEFAULT_TOKEN_START;
+ /** Default filter end token. */
+ public final static String TOKEN_END = FilterSet.DEFAULT_TOKEN_END;
+
+ /** Name of this project. */
+ private String name;
+ /** Description for this project (if any). */
+ private String description;
+
+ /** Project properties map (String to String). */
+ private Hashtable properties = new Hashtable();
+ /**
+ * Map of "user" properties (as created in the Ant task, for example).
+ * Note that these key/value pairs are also always put into the
+ * project properties, so only the project properties need to be queried.
+ * Mapping is String to String.
+ */
+ private Hashtable userProperties = new Hashtable();
+ /** Map of references within the project (paths etc) (String to Object). */
+ private Hashtable references = new Hashtable();
+
+ /** Name of the project's default target. */
+ private String defaultTarget;
+ /** Map from data type names to implementing classes (String to Class). */
+ private Hashtable dataClassDefinitions = new Hashtable();
+ /** Map from task names to implementing classes (String to Class). */
+ private Hashtable taskClassDefinitions = new Hashtable();
+ /**
+ * Map from task names to vectors of created tasks
+ * (String to Vector of Task). This is used to invalidate tasks if
+ * the task definition changes.
+ */
+ private Hashtable createdTasks = new Hashtable();
+ /** Map from target names to targets (String to Target). */
+ private Hashtable targets = new Hashtable();
+ /** Set of global filters. */
+ private FilterSet globalFilterSet = new FilterSet();
+ /**
+ * Wrapper around globalFilterSet. This collection only ever
+ * contains one FilterSet, but the wrapper is needed in order to
+ * make it easier to use the FileUtils interface.
+ */
+ private FilterSetCollection globalFilters = new FilterSetCollection(globalFilterSet);
+ /** Project base directory. */
+ private File baseDir;
+
+ /** List of listeners to notify of build events. */
+ private Vector listeners = new Vector();
+ protected Vector taskFactories = null;
+
+ /**
+ * The Ant core classloader - may be
+ * If the specified file name is relative it is resolved
+ * with respect to the given root directory.
+ *
+ * @param fileName The name of the file to resolve.
+ * Must not be
+ * If the specified file name is relative it is resolved
+ * with respect to the project's base directory.
+ *
+ * @param fileName The name of the file to resolve.
+ * Must not be
+ * This method uses PathTokenizer to separate the input path
+ * into its components. This handles DOS style paths in a relatively
+ * sensible way. The file separators are then converted to their platform
+ * specific versions.
+ *
+ * @param toProcess The path to be translated.
+ * May be
+ * The current target is first set to the "visiting" state, and pushed
+ * onto the "visiting" stack.
+ *
+ * An exception is then thrown if any child of the current node is in the
+ * visiting state, as that implies a circular dependency. The exception
+ * contains details of the cycle, using elements of the "visiting" stack.
+ *
+ * If any child has not already been "visited", this method is called
+ * recursively on it.
+ *
+ * The current target is then added to the ordered list of targets. Note
+ * that this is performed after the children have been visited in order
+ * to get the correct order. The current target is set to the "visited"
+ * state.
+ *
+ * By the time this method returns, the ordered list contains the sequence
+ * of targets up to and including the current target.
+ *
+ * @param root The current target to inspect.
+ * Must not be
+ * This is useful for logging purposes.
+ *
+ * @param element The element to describe.
+ * Must not be null if using
+ * parent classloader.
+ */
+ private ClassLoader coreLoader = null;
+
+ /** Records the latest task to be executed on a thread (Thread to Task). */
+ private Hashtable threadTasks = new Hashtable();
+
+ static {
+
+ // Determine the Java version by looking at available classes
+ // java.lang.CharSequence was introduced in JDK 1.4
+ // java.lang.StrictMath was introduced in JDK 1.3
+ // java.lang.ThreadLocal was introduced in JDK 1.2
+ // java.lang.Void was introduced in JDK 1.1
+ // Count up version until a NoClassDefFoundError ends the try
+
+ try {
+ javaVersion = JAVA_1_0;
+ Class.forName("java.lang.Void");
+ javaVersion = JAVA_1_1;
+ Class.forName("java.lang.ThreadLocal");
+ javaVersion = JAVA_1_2;
+ Class.forName("java.lang.StrictMath");
+ javaVersion = JAVA_1_3;
+ Class.forName("java.lang.CharSequence");
+ javaVersion = JAVA_1_4;
+ } catch (ClassNotFoundException cnfe) {
+ // swallow as we've hit the max class version that
+ // we have
+ }
+ }
+
+ /** Instance of a utility class to use for file operations. */
+ private FileUtils fileUtils;
+
+ /**
+ * Creates a new Ant project.
+ */
+ public Project() {
+ fileUtils = FileUtils.newFileUtils();
+ }
+
+ /**
+ * Initialises the project.
+ *
+ * This involves setting the default task definitions and loading the
+ * system properties.
+ *
+ * @exception BuildException if the default task list cannot be loaded
+ */
+ public void init() throws BuildException {
+ setJavaVersionProperty();
+
+ String defs = "/org/apache/tools/ant/taskdefs/defaults.properties";
+
+ try {
+ Properties props = new Properties();
+ InputStream in = this.getClass().getResourceAsStream(defs);
+ if (in == null) {
+ throw new BuildException("Can't load default task list");
+ }
+ props.load(in);
+ in.close();
+
+ Enumeration enum = props.propertyNames();
+ while (enum.hasMoreElements()) {
+ String key = (String) enum.nextElement();
+ String value = props.getProperty(key);
+ try {
+ Class taskClass = Class.forName(value);
+ addTaskDefinition(key, taskClass);
+ } catch (NoClassDefFoundError ncdfe) {
+ log("Could not load a dependent class (" + ncdfe.getMessage() + ") for task " + key, MSG_DEBUG);
+ } catch (ClassNotFoundException cnfe) {
+ log("Could not load class (" + value + ") for task " + key, MSG_DEBUG);
+ }
+ }
+ } catch (IOException ioe) {
+ throw new BuildException("Can't load default task list");
+ }
+
+ String dataDefs = "/org/apache/tools/ant/types/defaults.properties";
+
+ try{
+ Properties props = new Properties();
+ InputStream in = this.getClass().getResourceAsStream(dataDefs);
+ if (in == null) {
+ throw new BuildException("Can't load default datatype list");
+ }
+ props.load(in);
+ in.close();
+
+ Enumeration enum = props.propertyNames();
+ while (enum.hasMoreElements()) {
+ String key = (String) enum.nextElement();
+ String value = props.getProperty(key);
+ try {
+ Class dataClass = Class.forName(value);
+ addDataTypeDefinition(key, dataClass);
+ } catch (NoClassDefFoundError ncdfe) {
+ // ignore...
+ } catch (ClassNotFoundException cnfe) {
+ // ignore...
+ }
+ }
+ } catch (IOException ioe) {
+ throw new BuildException("Can't load default datatype list");
+ }
+
+ setSystemProperties();
+ }
+
+ /**
+ * Sets the core classloader for the project. If a null
+ * classloader is specified, the parent classloader should be used.
+ *
+ * @param coreLoader The classloader to use for the project.
+ * May be null.
+ */
+ public void setCoreLoader(ClassLoader coreLoader) {
+ this.coreLoader = coreLoader;
+ }
+
+ /**
+ * Returns the core classloader to use for this project.
+ * This may be null, indicating that
+ * the parent classloader should be used.
+ *
+ * @return the core classloader to use for this project.
+ *
+ */
+ public ClassLoader getCoreLoader() {
+ return coreLoader;
+ }
+
+ /**
+ * Adds a build listener to the list. This listener will
+ * be notified of build events for this project.
+ *
+ * @param listener The listener to add to the list.
+ * Must not be null.
+ */
+ public void addBuildListener(BuildListener listener) {
+ listeners.addElement(listener);
+ }
+
+ /**
+ * Removes a build listener from the list. This listener
+ * will no longer be notified of build events for this project.
+ *
+ * @param listener The listener to remove from the list.
+ * Should not be null.
+ */
+ public void removeBuildListener(BuildListener listener) {
+ listeners.removeElement(listener);
+ }
+
+ /**
+ * Returns a list of build listeners for the project. The returned
+ * vector is "live" and so should not be modified.
+ *
+ * @return a list of build listeners for the project
+ */
+ public Vector getBuildListeners() {
+ return listeners;
+ }
+
+ /**
+ * Writes a message to the log with the default log level
+ * of MSG_INFO
+ * @param msg The text to log. Should not be null.
+ */
+
+ public void log(String msg) {
+ log(msg, MSG_INFO);
+ }
+
+ /**
+ * Writes a project level message to the log with the given log level.
+ * @param msg The text to log. Should not be null.
+ * @param msgLevel The priority level to log at.
+ */
+ public void log(String msg, int msgLevel) {
+ fireMessageLogged(this, msg, msgLevel);
+ }
+
+ /**
+ * Writes a task level message to the log with the given log level.
+ * @param task The task to use in the log. Must not be null.
+ * @param msg The text to log. Should not be null.
+ * @param msgLevel The priority level to log at.
+ */
+ public void log(Task task, String msg, int msgLevel) {
+ fireMessageLogged(task, msg, msgLevel);
+ }
+
+ /**
+ * Writes a target level message to the log with the given log level.
+ * @param target The target to use in the log.
+ * Must not be null.
+ * @param msg The text to log. Should not be null.
+ * @param msgLevel The priority level to log at.
+ */
+ public void log(Target target, String msg, int msgLevel) {
+ fireMessageLogged(target, msg, msgLevel);
+ }
+
+ /**
+ * Returns the set of global filters.
+ *
+ * @return the set of global filters
+ */
+ public FilterSet getGlobalFilterSet() {
+ return globalFilterSet;
+ }
+
+ /**
+ * Sets a property. Any existing property of the same name
+ * is overwritten, unless it is a user property.
+ * @param name The name of property to set.
+ * Must not be null.
+ * @param value The new value of the property.
+ * Must not be null.
+ */
+ public void setProperty(String name, String value) {
+ // command line properties take precedence
+ if (null != userProperties.get(name)) {
+ log("Override ignored for user property " + name, MSG_VERBOSE);
+ return;
+ }
+
+ if (null != properties.get(name)) {
+ log("Overriding previous definition of property " + name,
+ MSG_VERBOSE);
+ }
+
+ log("Setting project property: " + name + " -> " +
+ value, MSG_DEBUG);
+ properties.put(name, value);
+ }
+
+ /**
+ * Sets a property if no value currently exists. If the property
+ * exists already, a message is logged and the method returns with
+ * no other effect.
+ *
+ * @param name The name of property to set.
+ * Must not be null.
+ * @param value The new value of the property.
+ * Must not be null.
+ * @since 1.5
+ */
+ public void setNewProperty(String name, String value) {
+ if (null != properties.get(name)) {
+ log("Override ignored for property " + name, MSG_VERBOSE);
+ return;
+ }
+ log("Setting project property: " + name + " -> " +
+ value, MSG_DEBUG);
+ properties.put(name, value);
+ }
+
+ /**
+ * Sets a user property, which cannot be overwritten by
+ * set/unset property calls. Any previous value is overwritten.
+ * @param name The name of property to set.
+ * Must not be null.
+ * @param value The new value of the property.
+ * Must not be null.
+ * @see #setProperty(String,String)
+ */
+ public void setUserProperty(String name, String value) {
+ log("Setting ro project property: " + name + " -> " +
+ value, MSG_DEBUG);
+ userProperties.put(name, value);
+ properties.put(name, value);
+ }
+
+ /**
+ * Sets a property unless it is already defined as a user property
+ * (in which case the method returns silently).
+ */
+ private void setPropertyInternal(String name, String value) {
+ if (null != userProperties.get(name)) {
+ return;
+ }
+ properties.put(name, value);
+ }
+
+ /**
+ * Returns the value of a property, if it is set.
+ *
+ * @param name The name of the property.
+ * May be null, in which case
+ * the return value is also null.
+ * @return the property value, or null for no match
+ * or if a null name is provided.
+ */
+ public String getProperty(String name) {
+ if (name == null) {
+ return null;
+ }
+ String property = (String) properties.get(name);
+ return property;
+ }
+
+ /**
+ * Replaces ${} style constructions in the given value with the
+ * string value of the corresponding data types.
+ *
+ * @param value The string to be scanned for property references.
+ * May be null.
+ *
+ * @return the given string with embedded property names replaced
+ * by values, or null if the given string is
+ * null.
+ *
+ * @exception BuildException if the given value has an unclosed property name,
+ * e.g. ${xxx
+ */
+ public String replaceProperties(String value)
+ throws BuildException {
+ return ProjectHelper.replaceProperties(this, value, properties);
+ }
+
+ /**
+ * Returns the value of a user property, if it is set.
+ *
+ * @param name The name of the property.
+ * May be null, in which case
+ * the return value is also null.
+ * @return the property value, or null for no match
+ * or if a null name is provided.
+ */
+ public String getUserProperty(String name) {
+ if (name == null) {
+ return null;
+ }
+ String property = (String) userProperties.get(name);
+ return property;
+ }
+
+ /**
+ * Returns a copy of the properties table.
+ * @return a hashtable containing all properties (including user properties).
+ */
+ public Hashtable getProperties() {
+ Hashtable propertiesCopy = new Hashtable();
+
+ Enumeration e = properties.keys();
+ while (e.hasMoreElements()) {
+ Object name = e.nextElement();
+ Object value = properties.get(name);
+ propertiesCopy.put(name, value);
+ }
+
+ return propertiesCopy;
+ }
+
+ /**
+ * Returns a copy of the user property hashtable
+ * @return a hashtable containing just the user properties
+ */
+ public Hashtable getUserProperties() {
+ Hashtable propertiesCopy = new Hashtable();
+
+ Enumeration e = userProperties.keys();
+ while (e.hasMoreElements()) {
+ Object name = e.nextElement();
+ Object value = properties.get(name);
+ propertiesCopy.put(name, value);
+ }
+
+ return propertiesCopy;
+ }
+
+ /**
+ * Sets the default target of the project.
+ *
+ * @param defaultTarget The name of the default target for this project.
+ * May be null, indicating that there is
+ * no default target.
+ *
+ * @deprecated use setDefault
+ * @see #setDefault(String)
+ */
+ public void setDefaultTarget(String defaultTarget) {
+ this.defaultTarget = defaultTarget;
+ }
+
+ /**
+ * Returns the name of the default target of the project.
+ * @return name of the default target or
+ * null if no default has been set.
+ */
+ public String getDefaultTarget() {
+ return defaultTarget;
+ }
+
+ /**
+ * Sets the default target of the project.
+ *
+ * @param defaultTarget The name of the default target for this project.
+ * May be null, indicating that there is
+ * no default target.
+ */
+ public void setDefault(String defaultTarget) {
+ this.defaultTarget = defaultTarget;
+ }
+
+ /**
+ * Sets the name of the project, also setting the user
+ * property ant.project.name.
+ *
+ * @param name The name of the project.
+ * Must not be null.
+ */
+ public void setName(String name) {
+ setUserProperty("ant.project.name", name);
+ this.name = name;
+ }
+
+ /**
+ * Returns the project name, if one has been set.
+ *
+ * @return the project name, or null if it hasn't been set.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Sets the project description.
+ *
+ * @param description The description of the project.
+ * May be null.
+ */
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ /**
+ * Returns the project description, if one has been set.
+ *
+ * @return the project description, or null if it hasn't
+ * been set.
+ */
+ public String getDescription() {
+ return description;
+ }
+
+ /**
+ * Adds a filter to the set of global filters.
+ *
+ * @param token The token to filter.
+ * Must not be null.
+ * @deprecated Use getGlobalFilterSet().addFilter(token,value)
+ *
+ * @see #getGlobalFilterSet()
+ * @see FilterSet#addFilter(String,String)
+ */
+ public void addFilter(String token, String value) {
+ if (token == null) {
+ return;
+ }
+
+ globalFilterSet.addFilter(new FilterSet.Filter(token, value));
+ }
+
+ /**
+ * Returns a hashtable of global filters, mapping tokens to values.
+ *
+ * @return a hashtable of global filters, mapping tokens to values
+ * (String to String).
+ *
+ * @deprecated Use getGlobalFilterSet().getFilterHash()
+ *
+ * @see #getGlobalFilterSet()
+ * @see FilterSet#getFilterHash()
+ */
+ public Hashtable getFilters() {
+ // we need to build the hashtable dynamically
+ return globalFilterSet.getFilterHash();
+ }
+
+ /**
+ * Sets the base directory for the project, checking that
+ * the given filename exists and is a directory.
+ *
+ * @param baseD The project base directory.
+ * Must not be null.
+ *
+ * @exception BuildException if the directory if invalid
+ */
+ public void setBasedir(String baseD) throws BuildException {
+ setBaseDir(new File(baseD));
+ }
+
+ /**
+ * Sets the base directory for the project, checking that
+ * the given file exists and is a directory.
+ *
+ * @param baseDir The project base directory.
+ * Must not be null.
+ * @exception BuildException if the specified file doesn't exist or
+ * isn't a directory
+ */
+ public void setBaseDir(File baseDir) throws BuildException {
+ baseDir = fileUtils.normalize(baseDir.getAbsolutePath());
+ if (!baseDir.exists()) {
+ throw new BuildException("Basedir " + baseDir.getAbsolutePath() + " does not exist");
+ }
+ if (!baseDir.isDirectory()) {
+ throw new BuildException("Basedir " + baseDir.getAbsolutePath() + " is not a directory");
+ }
+ this.baseDir = baseDir;
+ setPropertyInternal( "basedir", this.baseDir.getPath());
+ String msg = "Project base dir set to: " + this.baseDir;
+ log(msg, MSG_VERBOSE);
+ }
+
+ /**
+ * Returns the base directory of the project as a file object.
+ *
+ * @return the project base directory, or null if the
+ * base directory has not been successfully set to a valid value.
+ */
+ public File getBaseDir() {
+ if (baseDir == null) {
+ try {
+ setBasedir(".");
+ } catch (BuildException ex) {
+ ex.printStackTrace();
+ }
+ }
+ return baseDir;
+ }
+
+ /**
+ * Returns the version of Java this class is running under.
+ * @return the version of Java as a String, e.g. "1.1"
+ */
+ public static String getJavaVersion() {
+ return javaVersion;
+ }
+
+ /**
+ * Sets the ant.java.version property and tests for
+ * unsupported JVM versions. If the version is supported,
+ * verbose log messages are generated to record the Java version
+ * and operating system name.
+ *
+ * @exception BuildException if this Java version is not supported
+ *
+ * @see #getJavaVersion()
+ */
+ public void setJavaVersionProperty() throws BuildException {
+ setPropertyInternal("ant.java.version", javaVersion);
+
+ // sanity check
+ if (javaVersion == JAVA_1_0) {
+ throw new BuildException("Ant cannot work on Java 1.0");
+ }
+
+ log("Detected Java version: " + javaVersion + " in: " + System.getProperty("java.home"), MSG_VERBOSE);
+
+ log("Detected OS: " + System.getProperty("os.name"), MSG_VERBOSE);
+ }
+
+ /**
+ * Adds all system properties which aren't already defined as
+ * user properties to the project properties.
+ */
+ public void setSystemProperties() {
+ Properties systemP = System.getProperties();
+ Enumeration e = systemP.keys();
+ while (e.hasMoreElements()) {
+ Object name = e.nextElement();
+ String value = systemP.get(name).toString();
+ this.setPropertyInternal(name.toString(), value);
+ }
+ }
+
+ /**
+ * Adds a new task definition to the project.
+ * Attempting to override an existing definition with an
+ * equivalent one (i.e. with the same classname) results in
+ * a verbose log message. Attempting to override an existing definition
+ * with a different one results in a warning log message and
+ * invalidates any tasks which have already been created with the
+ * old definition.
+ *
+ * @param taskName The name of the task to add.
+ * Must not be null.
+ * @param taskClass The full name of the class implementing the task.
+ * Must not be null.
+ *
+ * @exception BuildException if the class is unsuitable for being an Ant
+ * task. An error level message is logged before
+ * this exception is thrown.
+ *
+ * @see #checkTaskClass(Class)
+ */
+ public void addTaskDefinition(String taskName, Class taskClass) throws BuildException {
+ Class old = (Class)taskClassDefinitions.get(taskName);
+ if (null != old) {
+ if (old.equals(taskClass)) {
+ log("Ignoring override for task " + taskName
+ + ", it is already defined by the same class.",
+ MSG_VERBOSE);
+ return;
+ } else {
+ log("Trying to override old definition of task "+taskName,
+ MSG_WARN);
+ invalidateCreatedTasks(taskName);
+ }
+ }
+
+ String msg = " +User task: " + taskName + " " + taskClass.getName();
+ log(msg, MSG_DEBUG);
+ checkTaskClass(taskClass);
+ taskClassDefinitions.put(taskName, taskClass);
+ }
+
+ /**
+ * Checks whether or not a class is suitable for serving as Ant task.
+ * Ant task implementation classes must be public, concrete, and have
+ * a no-arg constructor.
+ *
+ * @exception BuildException if the class is unsuitable for being an Ant
+ * task. An error level message is logged before
+ * this exception is thrown.
+ */
+ public void checkTaskClass(final Class taskClass) throws BuildException {
+ if(!Modifier.isPublic(taskClass.getModifiers())) {
+ final String message = taskClass + " is not public";
+ log(message, Project.MSG_ERR);
+ throw new BuildException(message);
+ }
+ if(Modifier.isAbstract(taskClass.getModifiers())) {
+ final String message = taskClass + " is abstract";
+ log(message, Project.MSG_ERR);
+ throw new BuildException(message);
+ }
+ try {
+ taskClass.getConstructor( null );
+ // don't have to check for public, since
+ // getConstructor finds public constructors only.
+ } catch(NoSuchMethodException e) {
+ final String message = "No public no-arg constructor in " + taskClass;
+ log(message, Project.MSG_ERR);
+ throw new BuildException(message);
+ }
+ if( !Task.class.isAssignableFrom(taskClass) ) {
+ TaskAdapter.checkTaskClass(taskClass, this);
+ }
+ }
+
+ /**
+ * Returns the current task definition hashtable. The returned hashtable is
+ * "live" and so should not be modified.
+ *
+ * @return a map of from task name to implementing class
+ * (String to Class).
+ */
+ public Hashtable getTaskDefinitions() {
+ return taskClassDefinitions;
+ }
+
+ /**
+ * Adds a new datatype definition.
+ * Attempting to override an existing definition with an
+ * equivalent one (i.e. with the same classname) results in
+ * a verbose log message. Attempting to override an existing definition
+ * with a different one results in a warning log message, but the
+ * definition is changed.
+ *
+ * @param typeName The name of the datatype.
+ * Must not be null.
+ * @param taskClass The full name of the class implementing the datatype.
+ * Must not be null.
+ */
+ public void addDataTypeDefinition(String typeName, Class typeClass) {
+ Class old = (Class)dataClassDefinitions.get(typeName);
+ if (null != old) {
+ if (old.equals(typeClass)) {
+ log("Ignoring override for datatype " + typeName
+ + ", it is already defined by the same class.",
+ MSG_VERBOSE);
+ return;
+ } else {
+ log("Trying to override old definition of datatype "+typeName,
+ MSG_WARN);
+ }
+ }
+
+ String msg = " +User datatype: " + typeName + " " + typeClass.getName();
+ log(msg, MSG_DEBUG);
+ dataClassDefinitions.put(typeName, typeClass);
+ }
+
+ /**
+ * Returns the current datatype definition hashtable. The returned hashtable is
+ * "live" and so should not be modified.
+ *
+ * @return a map of from datatype name to implementing class
+ * (String to Class).
+ */
+ public Hashtable getDataTypeDefinitions() {
+ return dataClassDefinitions;
+ }
+
+ /**
+ * Adds a new target to the project.
+ *
+ * @param target The target to be added to the project.
+ * Must not be null.
+ *
+ * @exception BuildException if the target already exists in the project
+ *
+ * @see Project#addOrReplaceTarget
+ */
+ public void addTarget(Target target) {
+ String name = target.getName();
+ if (targets.get(name) != null) {
+ throw new BuildException("Duplicate target: `"+name+"'");
+ }
+ addOrReplaceTarget(name, target);
+ }
+
+ /**
+ * Adds a new target to the project.
+ *
+ * @param targetName The name to use for the target.
+ * Must not be null.
+ * @param target The target to be added to the project.
+ * Must not be null.
+ *
+ * @exception BuildException if the target already exists in the project
+ *
+ * @see Project#addOrReplaceTarget
+ */
+ public void addTarget(String targetName, Target target)
+ throws BuildException {
+ if (targets.get(targetName) != null) {
+ throw new BuildException("Duplicate target: `"+targetName+"'");
+ }
+ addOrReplaceTarget(targetName, target);
+ }
+
+ /**
+ * Adds a target to the project, or replaces one with the same
+ * name.
+ *
+ * @param target The target to be added or replaced in the project.
+ * Must not be null.
+ */
+ public void addOrReplaceTarget(Target target) {
+ addOrReplaceTarget(target.getName(), target);
+ }
+
+ /**
+ * Adds a target to the project, or replaces one with the same
+ * name.
+ *
+ * @param targetName The name to use for the target.
+ * Must not be null.
+ * @param target The target to be added or replaced in the project.
+ * Must not be null.
+ */
+ public void addOrReplaceTarget(String targetName, Target target) {
+ String msg = " +Target: " + targetName;
+ log(msg, MSG_DEBUG);
+ target.setProject(this);
+ targets.put(targetName, target);
+ }
+
+ /**
+ * Returns the hashtable of targets. The returned hashtable
+ * is "live" and so should not be modified.
+ * @return a map from name to target (String to Target).
+ */
+ public Hashtable getTargets() {
+ return targets;
+ }
+
+ /** Add a task factory, allowing uesr code to create tasks
+ */
+ public void addTaskFactory( TaskFactory fact ) {
+ if( taskFactories==null ) {
+ taskFactories=new Vector();
+ }
+ taskFactories.addElement( fact );
+ }
+
+ /**
+ * Creates a new instance of a task.
+ *
+ * @param taskType The name of the task to create an instance of.
+ * Must not be null.
+ *
+ * @return an instance of the specified task, or null if
+ * the task name is not recognised.
+ *
+ * @exception BuildException if the task name is recognised but task
+ * creation fails.
+ */
+ public Task createTask(String taskType) throws BuildException {
+ // XXX Deprecate in a future version
+ return createTask( null, taskType );
+ }
+
+ /**
+ * create a new task instance
+ * @param taskType name of the task
+ * @param ns namespace of the task ( typically the SAX2 namespace )
+ * @throws BuildException when task creation goes bad
+ * @return null if the task name is unknown
+ */
+ public Task createTask(String ns, String taskType) throws BuildException {
+ Task task = null;
+ if( taskFactories!=null ) {
+ for( int i=0; inull.
+ */
+ private void addCreatedTask(String type, Task task) {
+ synchronized (createdTasks) {
+ Vector v = (Vector) createdTasks.get(type);
+ if (v == null) {
+ v = new Vector();
+ createdTasks.put(type, v);
+ }
+ v.addElement(task);
+ }
+ }
+
+ /**
+ * Mark tasks as invalid which no longer are of the correct type
+ * for a given taskname.
+ *
+ * @param type The name of the type of task to invalidate.
+ * Must not be null.
+ */
+ private void invalidateCreatedTasks(String type) {
+ synchronized (createdTasks) {
+ Vector v = (Vector) createdTasks.get(type);
+ if (v != null) {
+ Enumeration enum = v.elements();
+ while (enum.hasMoreElements()) {
+ Task t = (Task) enum.nextElement();
+ t.markInvalid();
+ }
+ v.removeAllElements();
+ createdTasks.remove(type);
+ }
+ }
+ }
+
+ /**
+ * Creates a new instance of a data type.
+ *
+ * @param taskType The name of the data type to create an instance of.
+ * Must not be null.
+ *
+ * @return an instance of the specified data type, or null if
+ * the data type name is not recognised.
+ *
+ * @exception BuildException if the data type name is recognised but
+ * instance creation fails.
+ */
+ public Object createDataType(String typeName) throws BuildException {
+ Class c = (Class) dataClassDefinitions.get(typeName);
+
+ if (c == null) {
+ return null;
+ }
+
+ try {
+ java.lang.reflect.Constructor ctor = null;
+ boolean noArg = false;
+ // DataType can have a "no arg" constructor or take a single
+ // Project argument.
+ try {
+ ctor = c.getConstructor(new Class[0]);
+ noArg = true;
+ } catch (NoSuchMethodException nse) {
+ ctor = c.getConstructor(new Class[] {Project.class});
+ noArg = false;
+ }
+
+ Object o = null;
+ if (noArg) {
+ o = ctor.newInstance(new Object[0]);
+ } else {
+ o = ctor.newInstance(new Object[] {this});
+ }
+ if (o instanceof ProjectComponent) {
+ ((ProjectComponent)o).setProject(this);
+ }
+ String msg = " +DataType: " + typeName;
+ log (msg, MSG_DEBUG);
+ return o;
+ } catch (java.lang.reflect.InvocationTargetException ite) {
+ Throwable t = ite.getTargetException();
+ String msg = "Could not create datatype of type: "
+ + typeName + " due to " + t;
+ throw new BuildException(msg, t);
+ } catch (Throwable t) {
+ String msg = "Could not create datatype of type: "
+ + typeName + " due to " + t;
+ throw new BuildException(msg, t);
+ }
+ }
+
+ /**
+ * Execute the specified sequence of targets, and the targets
+ * they depend on.
+ *
+ * @param targetNames A vector of target name strings to execute.
+ * Must not be null.
+ *
+ * @exception BuildException if the build failed
+ */
+ public void executeTargets(Vector targetNames) throws BuildException {
+ Throwable error = null;
+
+ for (int i = 0; i < targetNames.size(); i++) {
+ executeTarget((String)targetNames.elementAt(i));
+ }
+ }
+
+ /**
+ * Demultiplexes output so that each task receives the appropriate
+ * messages. If the current thread is not currently executing a task,
+ * the message is logged directly.
+ *
+ * @param line Message to handle. Should not be null.
+ * @param isError Whether the text represents an error (true)
+ * or information (false).
+ */
+ public void demuxOutput(String line, boolean isError) {
+ Task task = (Task)threadTasks.get(Thread.currentThread());
+ if (task == null) {
+ fireMessageLogged(this, line, isError ? MSG_ERR : MSG_INFO);
+ }
+ else {
+ if (isError) {
+ task.handleErrorOutput(line);
+ }
+ else {
+ task.handleOutput(line);
+ }
+ }
+ }
+
+ /**
+ * Executes the specified target and any targets it depends on.
+ *
+ * @param targetName The name of the target to execute.
+ * Must not be null.
+ *
+ * @exception BuildException if the build failed
+ */
+ public void executeTarget(String targetName) throws BuildException {
+
+ // sanity check ourselves, if we've been asked to build nothing
+ // then we should complain
+
+ if (targetName == null) {
+ String msg = "No target specified";
+ throw new BuildException(msg);
+ }
+
+ // Sort the dependency tree, and run everything from the
+ // beginning until we hit our targetName.
+ // Sorting checks if all the targets (and dependencies)
+ // exist, and if there is any cycle in the dependency
+ // graph.
+ Vector sortedTargets = topoSort(targetName, targets);
+
+ int curidx = 0;
+ Target curtarget;
+
+ do {
+ curtarget = (Target) sortedTargets.elementAt(curidx++);
+ curtarget.performTasks();
+ } while (!curtarget.getName().equals(targetName));
+ }
+
+ /**
+ * Returns the canonical form of a filename.
+ * null.
+ *
+ * @param rootDir The directory to resolve relative file names with
+ * respect to. May be null, in which case
+ * the current directory is used.
+ *
+ * @deprecated
+ */
+ public File resolveFile(String fileName, File rootDir) {
+ return fileUtils.resolveFile(rootDir, fileName);
+ }
+
+ /**
+ * Returns the canonical form of a filename.
+ * null.
+ */
+ public File resolveFile(String fileName) {
+ return fileUtils.resolveFile(baseDir, fileName);
+ }
+
+ /**
+ * Translates a path into its native (platform specific) format.
+ * null.
+ *
+ * @return the native version of the specified path or
+ * an empty string if the path is null or empty.
+ *
+ * @see PathTokenizer
+ */
+ public static String translatePath(String toProcess) {
+ if ( toProcess == null || toProcess.length() == 0 ) {
+ return "";
+ }
+
+ StringBuffer path = new StringBuffer(toProcess.length() + 50);
+ PathTokenizer tokenizer = new PathTokenizer(toProcess);
+ while (tokenizer.hasMoreTokens()) {
+ String pathComponent = tokenizer.nextToken();
+ pathComponent = pathComponent.replace('/', File.separatorChar);
+ pathComponent = pathComponent.replace('\\', File.separatorChar);
+ if (path.length() != 0) {
+ path.append(File.pathSeparatorChar);
+ }
+ path.append(pathComponent);
+ }
+
+ return path.toString();
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a destination.
+ * No filtering is performed.
+ *
+ * @param sourceFile Name of file to copy from.
+ * Must not be null.
+ * @param destFile Name of file to copy to.
+ * Must not be null.
+ *
+ * @exception IOException if the copying fails
+ *
+ * @deprecated
+ */
+ public void copyFile(String sourceFile, String destFile) throws IOException {
+ fileUtils.copyFile(sourceFile, destFile);
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a destination
+ * specifying if token filtering should be used.
+ *
+ * @param sourceFile Name of file to copy from.
+ * Must not be null.
+ * @param destFile Name of file to copy to.
+ * Must not be null.
+ * @param filtering Whether or not token filtering should be used during
+ * the copy.
+ *
+ * @exception IOException if the copying fails
+ *
+ * @deprecated
+ */
+ public void copyFile(String sourceFile, String destFile, boolean filtering)
+ throws IOException {
+ fileUtils.copyFile(sourceFile, destFile, filtering ? globalFilters : null);
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a
+ * destination specifying if token filtering should be used and if
+ * source files may overwrite newer destination files.
+ *
+ * @param sourceFile Name of file to copy from.
+ * Must not be null.
+ * @param destFile Name of file to copy to.
+ * Must not be null.
+ * @param filtering Whether or not token filtering should be used during
+ * the copy.
+ * @param overwrite Whether or not the destination file should be
+ * overwritten if it already exists.
+ *
+ * @exception IOException if the copying fails
+ *
+ * @deprecated
+ */
+ public void copyFile(String sourceFile, String destFile, boolean filtering,
+ boolean overwrite) throws IOException {
+ fileUtils.copyFile(sourceFile, destFile, filtering ? globalFilters : null, overwrite);
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a
+ * destination specifying if token filtering should be used, if
+ * source files may overwrite newer destination files, and if the
+ * last modified time of the resulting file should be set to
+ * that of the source file.
+ *
+ * @param sourceFile Name of file to copy from.
+ * Must not be null.
+ * @param destFile Name of file to copy to.
+ * Must not be null.
+ * @param filtering Whether or not token filtering should be used during
+ * the copy.
+ * @param overwrite Whether or not the destination file should be
+ * overwritten if it already exists.
+ * @param preserveLastModified Whether or not the last modified time of
+ * the resulting file should be set to that
+ * of the source file.
+ *
+ * @exception IOException if the copying fails
+ *
+ * @deprecated
+ */
+ public void copyFile(String sourceFile, String destFile, boolean filtering,
+ boolean overwrite, boolean preserveLastModified)
+ throws IOException {
+ fileUtils.copyFile(sourceFile, destFile, filtering ? globalFilters : null,
+ overwrite, preserveLastModified);
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a destination.
+ * No filtering is performed.
+ *
+ * @param sourceFile File to copy from.
+ * Must not be null.
+ * @param destFile File to copy to.
+ * Must not be null.
+ *
+ * @exception IOException if the copying fails
+ *
+ * @deprecated
+ */
+ public void copyFile(File sourceFile, File destFile) throws IOException {
+ fileUtils.copyFile(sourceFile, destFile);
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a destination
+ * specifying if token filtering should be used.
+ *
+ * @param sourceFile File to copy from.
+ * Must not be null.
+ * @param destFile File to copy to.
+ * Must not be null.
+ * @param filtering Whether or not token filtering should be used during
+ * the copy.
+ *
+ * @exception IOException if the copying fails
+ *
+ * @deprecated
+ */
+ public void copyFile(File sourceFile, File destFile, boolean filtering)
+ throws IOException {
+ fileUtils.copyFile(sourceFile, destFile, filtering ? globalFilters : null);
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a
+ * destination specifying if token filtering should be used and if
+ * source files may overwrite newer destination files.
+ *
+ * @param sourceFile File to copy from.
+ * Must not be null.
+ * @param destFile File to copy to.
+ * Must not be null.
+ * @param filtering Whether or not token filtering should be used during
+ * the copy.
+ * @param overwrite Whether or not the destination file should be
+ * overwritten if it already exists.
+ *
+ * @exception IOException
+ *
+ * @deprecated
+ */
+ public void copyFile(File sourceFile, File destFile, boolean filtering,
+ boolean overwrite) throws IOException {
+ fileUtils.copyFile(sourceFile, destFile, filtering ? globalFilters : null, overwrite);
+ }
+
+ /**
+ * Convenience method to copy a file from a source to a
+ * destination specifying if token filtering should be used, if
+ * source files may overwrite newer destination files, and if the
+ * last modified time of the resulting file should be set to
+ * that of the source file.
+ *
+ * @param sourceFile File to copy from.
+ * Must not be null.
+ * @param destFile File to copy to.
+ * Must not be null.
+ * @param filtering Whether or not token filtering should be used during
+ * the copy.
+ * @param overwrite Whether or not the destination file should be
+ * overwritten if it already exists.
+ * @param preserveLastModified Whether or not the last modified time of
+ * the resulting file should be set to that
+ * of the source file.
+ *
+ * @exception IOException if the copying fails
+ *
+ * @deprecated
+ */
+ public void copyFile(File sourceFile, File destFile, boolean filtering,
+ boolean overwrite, boolean preserveLastModified)
+ throws IOException {
+ fileUtils.copyFile(sourceFile, destFile, filtering ? globalFilters : null,
+ overwrite, preserveLastModified);
+ }
+
+ /**
+ * Calls File.setLastModified(long time) on Java above 1.1, and logs
+ * a warning on Java 1.1.
+ *
+ * @param File The file to set the last modified time on.
+ * Must not be null.
+ *
+ * @deprecated
+ *
+ * @exception BuildException if the last modified time cannot be set
+ * despite running on a platform with a version
+ * above 1.1.
+ */
+ public void setFileLastModified(File file, long time) throws BuildException {
+ if (getJavaVersion() == JAVA_1_1) {
+ log("Cannot change the modification time of " + file
+ + " in JDK 1.1", Project.MSG_WARN);
+ return;
+ }
+ fileUtils.setFileLastModified(file, time);
+ log("Setting modification time for " + file, MSG_VERBOSE);
+ }
+
+ /**
+ * Returns the boolean equivalent of a string, which is considered
+ * true if either "on", "true",
+ * or "yes" is found, ignoring case.
+ *
+ * @param s The string to convert to a boolean value.
+ * Must not be null.
+ *
+ * @return true if the given string is "on",
+ * "true" or "yes", or
+ * false otherwise.
+ */
+ public static boolean toBoolean(String s) {
+ return (s.equalsIgnoreCase("on") ||
+ s.equalsIgnoreCase("true") ||
+ s.equalsIgnoreCase("yes"));
+ }
+
+ /**
+ * Topologically sorts a set of targets.
+ *
+ * @param root The name of the root target. The sort is created in such
+ * a way that the sequence of Targets up to the root
+ * target is the minimum possible such sequence.
+ * Must not be null.
+ * @param targets A map of names to targets (String to Target).
+ * Must not be null.
+ * @return a vector of strings with the names of the targets in
+ * sorted order.
+ * @exception BuildException if there is a cyclic dependency among the
+ * targets, or if a named target does not exist.
+ */
+ public final Vector topoSort(String root, Hashtable targets)
+ throws BuildException {
+ Vector ret = new Vector();
+ Hashtable state = new Hashtable();
+ Stack visiting = new Stack();
+
+ // We first run a DFS based sort using the root as the starting node.
+ // This creates the minimum sequence of Targets to the root node.
+ // We then do a sort on any remaining unVISITED targets.
+ // This is unnecessary for doing our build, but it catches
+ // circular dependencies or missing Targets on the entire
+ // dependency tree, not just on the Targets that depend on the
+ // build Target.
+
+ tsort(root, targets, state, visiting, ret);
+ log("Build sequence for target `"+root+"' is "+ret, MSG_VERBOSE);
+ for (Enumeration en=targets.keys(); en.hasMoreElements();) {
+ String curTarget = (String)(en.nextElement());
+ String st = (String) state.get(curTarget);
+ if (st == null) {
+ tsort(curTarget, targets, state, visiting, ret);
+ }
+ else if (st == VISITING) {
+ throw new RuntimeException("Unexpected node in visiting state: "+curTarget);
+ }
+ }
+ log("Complete build sequence is "+ret, MSG_VERBOSE);
+ return ret;
+ }
+
+ /**
+ * Performs a single step in a recursive depth-first-search traversal of
+ * the target dependency tree.
+ * null.
+ * @param targets A mapping from names to targets (String to Target).
+ * Must not be null.
+ * @param state A mapping from target names to states
+ * (String to String).
+ * The states in question are "VISITING" and "VISITED".
+ * Must not be null.
+ * @param visiting A stack of targets which are currently being visited.
+ * Must not be null.
+ * @param ret The list to add target names to. This will end up
+ * containing the complete list of depenencies in
+ * dependency order.
+ * Must not be null.
+ *
+ * @exception BuildException if a non-existent target is specified or if
+ * a circular dependency is detected.
+ */
+ private final void tsort(String root, Hashtable targets,
+ Hashtable state, Stack visiting,
+ Vector ret)
+ throws BuildException {
+ state.put(root, VISITING);
+ visiting.push(root);
+
+ Target target = (Target)(targets.get(root));
+
+ // Make sure we exist
+ if (target == null) {
+ StringBuffer sb = new StringBuffer("Target `");
+ sb.append(root);
+ sb.append("' does not exist in this project. ");
+ visiting.pop();
+ if (!visiting.empty()) {
+ String parent = (String)visiting.peek();
+ sb.append("It is used from target `");
+ sb.append(parent);
+ sb.append("'.");
+ }
+
+ throw new BuildException(new String(sb));
+ }
+
+ for (Enumeration en=target.getDependencies(); en.hasMoreElements();) {
+ String cur = (String) en.nextElement();
+ String m=(String)state.get(cur);
+ if (m == null) {
+ // Not been visited
+ tsort(cur, targets, state, visiting, ret);
+ }
+ else if (m == VISITING) {
+ // Currently visiting this node, so have a cycle
+ throw makeCircularException(cur, visiting);
+ }
+ }
+
+ String p = (String) visiting.pop();
+ if (root != p) {
+ throw new RuntimeException("Unexpected internal error: expected to pop "+root+" but got "+p);
+ }
+ state.put(root, VISITED);
+ ret.addElement(target);
+ }
+
+ /**
+ * Builds an appropriate exception detailing a specified circular dependency.
+ *
+ * @param end The dependency to stop at. Must not be null.
+ * @param stk A stack of dependencies. Must not be null.
+ *
+ * @return a BuildException detailing the specified circular dependency.
+ */
+ private static BuildException makeCircularException(String end, Stack stk) {
+ StringBuffer sb = new StringBuffer("Circular dependency: ");
+ sb.append(end);
+ String c;
+ do {
+ c = (String)stk.pop();
+ sb.append(" <- ");
+ sb.append(c);
+ } while(!c.equals(end));
+ return new BuildException(new String(sb));
+ }
+
+ /**
+ * Adds a reference to the project.
+ *
+ * @param name The name of the reference. Must not be null.
+ * @param value The value of the reference. Must not be null.
+ */
+ public void addReference(String name, Object value) {
+ if (null != references.get(name)) {
+ log("Overriding previous definition of reference to " + name,
+ MSG_WARN);
+ }
+ log("Adding reference: " + name + " -> " + value, MSG_DEBUG);
+ references.put(name,value);
+ }
+
+ /**
+ * Returns a map of the references in the project (String to Object).
+ * The returned hashtable is "live" and so should not be modified.
+ *
+ * @return a map of the references in the project (String to Object).
+ */
+ public Hashtable getReferences() {
+ return references;
+ }
+
+ /**
+ * Looks up a reference by its key (ID).
+ *
+ * @param key The key for the desired reference.
+ * Must not be null.
+ *
+ * @return the reference with the specified ID, or null if
+ * there is no such reference in the project.
+ */
+ public Object getReference(String key) {
+ return references.get(key);
+ }
+
+ /**
+ * Returns a description of the type of the given element, with
+ * special handling for instances of tasks and data types.
+ * null.
+ *
+ * @return a description of the element type
+ *
+ * @since 1.95, Ant 1.5
+ */
+ public String getElementName(Object element) {
+ Hashtable elements = taskClassDefinitions;
+ Class elementClass = element.getClass();
+ String typeName = "task";
+ if (!elements.contains(elementClass)) {
+ elements = dataClassDefinitions;
+ typeName = "data type";
+ if (!elements.contains(elementClass)) {
+ elements = null;
+ }
+ }
+
+ if (elements != null) {
+ Enumeration e = elements.keys();
+ while (e.hasMoreElements()) {
+ String name = (String) e.nextElement();
+ Class clazz = (Class) elements.get(name);
+ if (elementClass.equals(clazz)) {
+ return "The <" + name + "> " + typeName;
+ }
+ }
+ }
+
+ return "Class " + elementClass.getName();
+ }
+
+ /**
+ * Sends a "build started" event to the build listeners for this project.
+ */
+ protected void fireBuildStarted() {
+ BuildEvent event = new BuildEvent(this);
+ for (int i = 0; i < listeners.size(); i++) {
+ BuildListener listener = (BuildListener) listeners.elementAt(i);
+ listener.buildStarted(event);
+ }
+ }
+
+ /**
+ * Sends a "build finished" event to the build listeners for this project.
+ * @param exception an exception indicating a reason for a build
+ * failure. May be null, indicating
+ * a successful build.
+ */
+ protected void fireBuildFinished(Throwable exception) {
+ BuildEvent event = new BuildEvent(this);
+ event.setException(exception);
+ for (int i = 0; i < listeners.size(); i++) {
+ BuildListener listener = (BuildListener) listeners.elementAt(i);
+ listener.buildFinished(event);
+ }
+ }
+
+
+ /**
+ * Sends a "target started" event to the build listeners for this project.
+ *
+ * @param target The target which is starting to build.
+ * Must not be null.
+ */
+ protected void fireTargetStarted(Target target) {
+ BuildEvent event = new BuildEvent(target);
+ for (int i = 0; i < listeners.size(); i++) {
+ BuildListener listener = (BuildListener) listeners.elementAt(i);
+ listener.targetStarted(event);
+ }
+ }
+
+ /**
+ * Sends a "target finished" event to the build listeners for this
+ * project.
+ *
+ * @param target The target which has finished building.
+ * Must not be null.
+ * @param exception an exception indicating a reason for a build
+ * failure. May be null, indicating
+ * a successful build.
+ */
+ protected void fireTargetFinished(Target target, Throwable exception) {
+ BuildEvent event = new BuildEvent(target);
+ event.setException(exception);
+ for (int i = 0; i < listeners.size(); i++) {
+ BuildListener listener = (BuildListener) listeners.elementAt(i);
+ listener.targetFinished(event);
+ }
+ }
+
+ /**
+ * Sends a "task started" event to the build listeners for this project.
+ *
+ * @param task The target which is starting to execute.
+ * Must not be null.
+ */
+ protected void fireTaskStarted(Task task) {
+ // register this as the current task on the current thread.
+ threadTasks.put(Thread.currentThread(), task);
+ BuildEvent event = new BuildEvent(task);
+ for (int i = 0; i < listeners.size(); i++) {
+ BuildListener listener = (BuildListener) listeners.elementAt(i);
+ listener.taskStarted(event);
+ }
+ }
+
+ /**
+ * Sends a "task finished" event to the build listeners for this
+ * project.
+ *
+ * @param task The task which has finished executing.
+ * Must not be null.
+ * @param exception an exception indicating a reason for a build
+ * failure. May be null, indicating
+ * a successful build.
+ */
+ protected void fireTaskFinished(Task task, Throwable exception) {
+ threadTasks.remove(Thread.currentThread());
+ System.out.flush();
+ System.err.flush();
+ BuildEvent event = new BuildEvent(task);
+ event.setException(exception);
+ for (int i = 0; i < listeners.size(); i++) {
+ BuildListener listener = (BuildListener) listeners.elementAt(i);
+ listener.taskFinished(event);
+ }
+ }
+
+ /**
+ * Sends a "message logged" event to the build listeners for this project.
+ *
+ * @param event The event to send. This should be built up with the
+ * appropriate task/target/project by the caller, so that
+ * this method can set the message and priority, then send
+ * the event. Must not be null.
+ * @param message The message to send. Should not be null.
+ * @param priority The priority of the message.
+ */
+ private void fireMessageLoggedEvent(BuildEvent event, String message, int priority) {
+ event.setMessage(message, priority);
+ for (int i = 0; i < listeners.size(); i++) {
+ BuildListener listener = (BuildListener) listeners.elementAt(i);
+ listener.messageLogged(event);
+ }
+ }
+
+ /**
+ * Sends a "message logged" project level event to the build listeners for
+ * this project.
+ *
+ * @param project The project generating the event.
+ * Should not be null.
+ * @param message The message to send. Should not be null.
+ * @param priority The priority of the message.
+ */
+ protected void fireMessageLogged(Project project, String message, int priority) {
+ BuildEvent event = new BuildEvent(project);
+ fireMessageLoggedEvent(event, message, priority);
+ }
+
+ /**
+ * Sends a "message logged" target level event to the build listeners for
+ * this project.
+ *
+ * @param target The target generating the event.
+ * Must not be null.
+ * @param message The message to send. Should not be null.
+ * @param priority The priority of the message.
+ */
+ protected void fireMessageLogged(Target target, String message, int priority) {
+ BuildEvent event = new BuildEvent(target);
+ fireMessageLoggedEvent(event, message, priority);
+ }
+
+ /**
+ * Sends a "message logged" task level event to the build listeners for
+ * this project.
+ *
+ * @param task The task generating the event.
+ * Must not be null.
+ * @param message The message to send. Should not be null.
+ * @param priority The priority of the message.
+ */
+ protected void fireMessageLogged(Task task, String message, int priority) {
+ BuildEvent event = new BuildEvent(task);
+ fireMessageLoggedEvent(event, message, priority);
+ }
+}
diff --git a/proposal/sandbox/embed/TaskAdapter.java b/proposal/sandbox/embed/TaskAdapter.java
index 5a6dad92c..b2c227d13 100644
--- a/proposal/sandbox/embed/TaskAdapter.java
+++ b/proposal/sandbox/embed/TaskAdapter.java
@@ -56,11 +56,10 @@ package org.apache.tools.ant;
import java.lang.reflect.Method;
-
-
/**
- * Use introspection to "adapt" an arbitrary Bean ( not extending Task, but with similar
- * patterns).
+ * Uses introspection to "adapt" an arbitrary Bean which doesn't
+ * itself extend Task, but still contains an execute method and optionally
+ * a setProject method.
*
* The adapter can also be used to wrap tasks that are loaded in a different class loader
* by ant, when used in programatic mode.
@@ -69,19 +68,28 @@ import java.lang.reflect.Method;
*/
public class TaskAdapter extends Task {
+ /** Object to act as a proxy for. */
private Object proxy;
private String methodName="execute";
+ Object proxy;
/**
- * Checks a class, whether it is suitable to be adapted by TaskAdapter.
+ * Checks whether or not a class is suitable to be adapted by TaskAdapter.
*
- * Checks conditions only, which are additionally required for a tasks
- * adapted by TaskAdapter. Thus, this method should be called by
- * {@link Project#checkTaskClass}.
+ * This only checks conditions which are additionally required for
+ * tasks adapted by TaskAdapter. Thus, this method should be called by
+ * Project.checkTaskClass.
*
* Throws a BuildException and logs as Project.MSG_ERR for
- * conditions, that will cause the task execution to fail.
+ * conditions that will cause the task execution to fail.
* Logs other suspicious conditions with Project.MSG_WARN.
+ *
+ * @param taskClass Class to test for suitability.
+ * Must not be null.
+ * @param project Project to log warnings/errors to.
+ * Must not be null.
+ *
+ * @see Project#checkTaskClass(Class)
*/
public static void checkTaskClass(final Class taskClass, final Project project) {
// Any task can be used via adapter. If it doesn't have any execute()
@@ -154,7 +162,7 @@ public class TaskAdapter extends Task {
}
/**
- * Do the execution.
+ * Executes the proxied task.
*/
public void execute() throws BuildException {
Method setProjectM = null;
@@ -201,12 +209,19 @@ public class TaskAdapter extends Task {
}
/**
- * Set the target object class
+ * Sets the target object to proxy for.
+ *
+ * @param o The target object. Must not be null.
*/
public void setProxy(Object o) {
this.proxy = o;
}
+ /**
+ * Returns the target object being proxied.
+ *
+ * @return the target proxy object
+ */
public Object getProxy() {
return this.proxy ;
}
diff --git a/proposal/sandbox/embed/TaskFactory.java b/proposal/sandbox/embed/TaskFactory.java
new file mode 100644
index 000000000..bda9acb3f
--- /dev/null
+++ b/proposal/sandbox/embed/TaskFactory.java
@@ -0,0 +1,95 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2000-2002 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "The Jakarta Project", "Ant", and "Apache Software
+ * Foundation" must not be used to endorse or promote products derived
+ * from this software without prior written permission. For written
+ * permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache"
+ * nor may "Apache" appear in their names without prior written
+ * permission of the Apache Group.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ *