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) {
checkTaskClass(taskClass);
AntTypeDefinition def = new AntTypeDefinition();
def.setName(taskName);
def.setClassLoader(taskClass.getClassLoader());
def.setClass(taskClass);
def.setAdapterClass(TaskAdapter.class);
def.setClassName(taskClass.getName());
def.setAdaptToClass(Task.class);
updateDataTypeDefinition(def);
}
/**
* 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.
*
* @param taskClass The class to be checked.
* 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.
*/
public void checkTaskClass(final Class taskClass) throws BuildException {
if (!Modifier.isPublic(taskClass.getModifiers())) {
final String message = taskClass + " is not public";
project.log(message, Project.MSG_ERR);
throw new BuildException(message);
}
if (Modifier.isAbstract(taskClass.getModifiers())) {
final String message = taskClass + " is abstract";
project.log(message, Project.MSG_ERR);
throw new BuildException(message);
}
try {
taskClass.getConstructor((Class[]) 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;
project.log(message, Project.MSG_ERR);
throw new BuildException(message);
}
if (!Task.class.isAssignableFrom(taskClass)) {
TaskAdapter.checkTaskClass(taskClass, project);
}
}
/**
* 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() {
synchronized (taskClassDefinitions) {
synchronized (antTypeTable) {
if (rebuildTaskClassDefinitions) {
taskClassDefinitions.clear();
for (Iterator i = antTypeTable.keySet().iterator();
i.hasNext();) {
String name = (String) i.next();
Class clazz = antTypeTable.getExposedClass(name);
if (clazz == null) {
continue;
}
if (Task.class.isAssignableFrom(clazz)) {
taskClassDefinitions.put(
name, antTypeTable.getTypeClass(name));
}
}
rebuildTaskClassDefinitions = false;
}
}
}
return taskClassDefinitions;
}
/**
* Returns the current type definition hashtable. The returned hashtable is
* "live" and so should not be modified.
*
* @return a map of from type name to implementing class
* (String to Class).
*/
public Hashtable getDataTypeDefinitions() {
synchronized (typeClassDefinitions) {
synchronized (antTypeTable) {
if (rebuildTypeClassDefinitions) {
typeClassDefinitions.clear();
for (Iterator i = antTypeTable.keySet().iterator();
i.hasNext();) {
String name = (String) i.next();
Class clazz = antTypeTable.getExposedClass(name);
if (clazz == null) {
continue;
}
if (!(Task.class.isAssignableFrom(clazz))) {
typeClassDefinitions.put(
name, antTypeTable.getTypeClass(name));
}
}
rebuildTypeClassDefinitions = false;
}
}
}
return typeClassDefinitions;
}
/**
* 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 typeClass The full name of the class implementing the datatype.
* Must not be null.
*/
public void addDataTypeDefinition(String typeName, Class typeClass) {
AntTypeDefinition def = new AntTypeDefinition();
def.setName(typeName);
def.setClass(typeClass);
updateDataTypeDefinition(def);
project.log(" +User datatype: " + typeName + " "
+ typeClass.getName(), Project.MSG_DEBUG);
}
/**
* Describe addDataTypeDefinition method here.
*
* @param def an AntTypeDefinition value.
*/
public void addDataTypeDefinition(AntTypeDefinition def) {
updateDataTypeDefinition(def);
}
/**
* 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 getAntTypeTable() {
return antTypeTable;
}
/**
* Creates a new instance of a task, adding it to a list of
* created tasks for later invalidation. This causes all tasks
* to be remembered until the containing project is removed
*
* Called from Project.createTask(), which can be called by tasks.
* The method should be deprecated, as it doesn't support ns and libs.
*
* @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 {
Task task = createNewTask(taskType);
if (task == null && taskType.equals(ANT_PROPERTY_TASK)) {
// quick fix for Ant.java use of property before
// initializing the project
addTaskDefinition(ANT_PROPERTY_TASK,
org.apache.tools.ant.taskdefs.Property.class);
task = createNewTask(taskType);
}
if (task != null) {
addCreatedTask(taskType, task);
}
return task;
}
/**
* Creates a new instance of a task. This task is not
* cached in the createdTasks list.
* @since ant1.6
* @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.
*/
private Task createNewTask(String taskType) throws BuildException {
Class c = getComponentClass(taskType);
if (c == null || !(Task.class.isAssignableFrom(c))) {
return null;
}
Object _task = createComponent(taskType);
if (_task == null) {
return null;
}
if (!(_task instanceof Task)) {
throw new BuildException("Expected a Task from '" + taskType + "' but got an instance of " + _task.getClass().getName() + " instead");
}
Task task = (Task) _task;
task.setTaskType(taskType);
// set default value, can be changed by the user
task.setTaskName(taskType);
project.log(" +Task: " + taskType, Project.MSG_DEBUG);
return task;
}
/**
* Keeps a record of all tasks that have been created so that they
* can be invalidated if a new task definition overrides the current one.
*
* @param type The name of the type of task which has been created.
* Must not be null.
*
* @param task The freshly created task instance.
* Must not be null.
*/
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(new WeakReference(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 taskEnum = v.elements();
while (taskEnum.hasMoreElements()) {
WeakReference ref = (WeakReference) taskEnum.nextElement();
Task t = (Task) ref.get();
//being a weak ref, it may be null by this point
if (t != null) {
t.markInvalid();
}
}
v.removeAllElements();
createdTasks.remove(type);
}
}
}
/**
* Creates a new instance of a data type.
*
* @param typeName 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 {
return createComponent(typeName);
}
/**
* Returns a description of the type of the given element.
*
* This is useful for logging purposes.
*
* @param element The element to describe.
* Must not be null.
*
* @return a description of the element type.
*
* @since Ant 1.6
*/
public String getElementName(Object element) {
return getElementName(element, false);
}
/**
* Returns a description of the type of the given element.
*
* This is useful for logging purposes.
*
* @param element The element to describe.
* Must not be null.
* @param brief whether to use a brief description.
* @return a description of the element type.
*
* @since Ant 1.7
*/
public String getElementName(Object element, boolean brief) {
// PR: I do not know what to do if the object class
// has multiple defines
// but this is for logging only...
String name = null;
Class elementClass = element.getClass();
for (Iterator i = antTypeTable.values().iterator(); i.hasNext();) {
AntTypeDefinition def = (AntTypeDefinition) i.next();
if (elementClass == def.getExposedClass(project)) {
name = def.getName();
return brief ? name : "The <" + name + "> type";
}
}
name = elementClass.getName();
return brief
? name.substring(name.lastIndexOf('.') + 1) : "Class " + name;
}
/**
* Check if definition is a valid definition--it may be a
* definition of an optional task that does not exist.
* @param def the definition to test.
* @return true if exposed type of definition is present.
*/
private boolean validDefinition(AntTypeDefinition def) {
return !(def.getTypeClass(project) == null
|| def.getExposedClass(project) == null);
}
/**
* Check if two definitions are the same.
* @param def the new definition.
* @param old the old definition.
* @return true if the two definitions are the same.
*/
private boolean sameDefinition(
AntTypeDefinition def, AntTypeDefinition old) {
boolean defValid = validDefinition(def);
boolean sameValidity = (defValid == validDefinition(old));
//must have same validity; then if they are valid they must also be the same:
return sameValidity && (!defValid || def.sameDefinition(old, project));
}
/**
* Update the component definition table with a new or
* modified definition.
* @param def the definition to update or insert.
*/
private void updateDataTypeDefinition(AntTypeDefinition def) {
String name = def.getName();
synchronized (antTypeTable) {
rebuildTaskClassDefinitions = true;
rebuildTypeClassDefinitions = true;
AntTypeDefinition old = antTypeTable.getDefinition(name);
if (old != null) {
if (sameDefinition(def, old)) {
return;
}
Class oldClass = antTypeTable.getExposedClass(name);
boolean isTask =
(oldClass != null && Task.class.isAssignableFrom(oldClass));
project.log("Trying to override old definition of "
+ (isTask ? "task " : "datatype ") + name,
(def.similarDefinition(old, project))
? Project.MSG_VERBOSE : Project.MSG_WARN);
if (isTask) {
invalidateCreatedTasks(name);
}
}
project.log(" +Datatype " + name + " " + def.getClassName(),
Project.MSG_DEBUG);
antTypeTable.put(name, def);
}
}
/**
* Called at the start of processing an antlib.
* @param uri the uri that is associated with this antlib.
*/
public void enterAntLib(String uri) {
antLibCurrentUri = uri;
antLibStack.push(uri);
}
/**
* @return the current antlib uri.
*/
public String getCurrentAntlibUri() {
return antLibCurrentUri;
}
/**
* Called at the end of processing an antlib.
*/
public void exitAntLib() {
antLibStack.pop();
antLibCurrentUri = (antLibStack.size() == 0)
? null : (String) antLibStack.peek();
}
/**
* Load ant's tasks.
*/
private void initTasks() {
ClassLoader classLoader = null;
classLoader = getClassLoader(classLoader);
String dataDefs = MagicNames.TASKDEF_PROPERTIES_RESOURCE;
InputStream in = null;
try {
Properties props = new Properties();
in = this.getClass().getResourceAsStream(dataDefs);
if (in == null) {
throw new BuildException(ERROR_NO_TASK_LIST_LOAD);
}
props.load(in);
Enumeration e = props.propertyNames();
while (e.hasMoreElements()) {
String name = (String) e.nextElement();
String className = props.getProperty(name);
AntTypeDefinition def = new AntTypeDefinition();
def.setName(name);
def.setClassName(className);
def.setClassLoader(classLoader);
def.setAdaptToClass(Task.class);
def.setAdapterClass(TaskAdapter.class);
antTypeTable.put(name, def);
}
} catch (IOException ex) {
throw new BuildException(ERROR_NO_TASK_LIST_LOAD);
} finally {
if (in != null) {
try {
in.close();
} catch (Exception ignore) {
// Ignore
}
}
}
}
private ClassLoader getClassLoader(ClassLoader classLoader) {
String buildSysclasspath = project.getProperty(MagicNames.BUILD_SYSCLASSPATH);
if (project.getCoreLoader() != null
&& !(BUILD_SYSCLASSPATH_ONLY.equals(buildSysclasspath))) {
classLoader = project.getCoreLoader();
}
return classLoader;
}
/**
* Load ant's datatypes.
*/
private void initTypes() {
ClassLoader classLoader = null;
classLoader = getClassLoader(classLoader);
String dataDefs = MagicNames.TYPEDEFS_PROPERTIES_RESOURCE;
InputStream in = null;
try {
Properties props = new Properties();
in = this.getClass().getResourceAsStream(dataDefs);
if (in == null) {
throw new BuildException(ERROR_NO_TYPE_LIST_LOAD);
}
props.load(in);
Enumeration e = props.propertyNames();
while (e.hasMoreElements()) {
String name = (String) e.nextElement();
String className = props.getProperty(name);
AntTypeDefinition def = new AntTypeDefinition();
def.setName(name);
def.setClassName(className);
def.setClassLoader(classLoader);
antTypeTable.put(name, def);
}
} catch (IOException ex) {
throw new BuildException(ERROR_NO_TYPE_LIST_LOAD);
} finally {
if (in != null) {
try {
in.close();
} catch (Exception ignore) {
// ignore
}
}
}
}
/**
* Called for each component name, check if the
* associated URI has been examined for antlibs.
*/
private synchronized void checkNamespace(String componentName) {
String uri = ProjectHelper.extractUriFromComponentName(componentName);
if ("".equals(uri)) {
uri = ProjectHelper.ANT_CORE_URI;
}
if (!uri.startsWith(ProjectHelper.ANTLIB_URI)) {
return; // namespace that does not contain antlib
}
if (checkedNamespaces.contains(uri)) {
return; // Already processed
}
checkedNamespaces.add(uri);
Typedef definer = new Typedef();
definer.setProject(project);
definer.init();
definer.setURI(uri);
//there to stop error messages being "null"
definer.setTaskName(uri);
//if this is left out, bad things happen. like all build files break
//on the first element encountered.
definer.setResource(Definer.makeResourceFromURI(uri));
// a fishing expedition :- ignore errors if antlib not present
definer.setOnError(new Typedef.OnError(Typedef.OnError.POLICY_IGNORE));
definer.execute();
}
/**
* Handler called to do decent diagnosis on instantiation failure.
* @param componentName component name.
* @param type component type, used in error messages
* @return a string containing as much diagnostics info as possible.
*/
public String diagnoseCreationFailure(String componentName, String type) {
StringWriter errorText = new StringWriter();
PrintWriter out = new PrintWriter(errorText);
out.println("Problem: failed to create " + type + " " + componentName);
//class of problem
boolean lowlevel = false;
boolean jars = false;
boolean definitions = false;
boolean antTask;
String home = System.getProperty(Launcher.USER_HOMEDIR);
File libDir = new File(home, Launcher.USER_LIBDIR);
//look up the name
AntTypeDefinition def = getDefinition(componentName);
if (def == null) {
//not a known type
boolean isAntlib = componentName.indexOf(MagicNames.ANTLIB_PREFIX) == 0;
out.println("Cause: The name is undefined.");
out.println("Action: Check the spelling.");
out.println("Action: Check that any custom tasks/types have been declared.");
out.println("Action: Check that any