org.apache.tools.ant.UnknownElement Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of testatoo-container-jetty-full Show documentation
Show all versions of testatoo-container-jetty-full Show documentation
Testatoo Jetty Container with JSP support
/*
* Copyright 2000-2004 The Apache Software Foundation
*
* 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 org.apache.tools.ant;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.io.IOException;
import org.apache.tools.ant.taskdefs.PreSetDef;
/**
* Wrapper class that holds all the information necessary to create a task
* or data type that did not exist when Ant started, or one which
* has had its definition updated to use a different implementation class.
*
*/
public class UnknownElement extends Task {
/**
* Holds the name of the task/type or nested child element of a
* task/type that hasn't been defined at parser time or has
* been redefined since original creation.
*/
private String elementName;
/**
* Holds the namespace of the element.
*/
private String namespace;
/**
* Holds the namespace qname of the element.
*/
private String qname;
/**
* The real object after it has been loaded.
*/
private Object realThing;
/**
* List of child elements (UnknownElements).
*/
private List/**/ children = null;
/** Specifies if a predefined definition has been done */
private boolean presetDefed = false;
/**
* Creates an UnknownElement for the given element name.
*
* @param elementName The name of the unknown element.
* Must not be null.
*/
public UnknownElement (String elementName) {
this.elementName = elementName;
}
/**
* @return the list of nested UnknownElements for this UnknownElement.
*/
public List getChildren() {
return children;
}
/**
* Returns the name of the XML element which generated this unknown
* element.
*
* @return the name of the XML element which generated this unknown
* element.
*/
public String getTag() {
return elementName;
}
/** Return the namespace of the XML element associated with this component.
*
* @return Namespace URI used in the xmlns declaration.
*/
public String getNamespace() {
return namespace;
}
/**
* Set the namespace of the XML element associated with this component.
* This method is typically called by the XML processor.
* If the namespace is "ant:current", the component helper
* is used to get the current antlib uri.
*
* @param namespace URI used in the xmlns declaration.
*/
public void setNamespace(String namespace) {
if (namespace.equals(ProjectHelper.ANT_CURRENT_URI)) {
ComponentHelper helper = ComponentHelper.getComponentHelper(
getProject());
namespace = helper.getCurrentAntlibUri();
}
this.namespace = namespace;
}
/** Return the qname of the XML element associated with this component.
*
* @return namespace Qname used in the element declaration.
*/
public String getQName() {
return qname;
}
/** Set the namespace qname of the XML element.
* This method is typically called by the XML processor.
*
* @param qname the qualified name of the element
*/
public void setQName(String qname) {
this.qname = qname;
}
/**
* Get the RuntimeConfigurable instance for this UnknownElement, containing
* the configuration information.
*
* @return the configuration info.
*/
public RuntimeConfigurable getWrapper() {
return super.getWrapper();
}
/**
* Creates the real object instance and child elements, then configures
* the attributes and text of the real object. This unknown element
* is then replaced with the real object in the containing target's list
* of children.
*
* @exception BuildException if the configuration fails
*/
public void maybeConfigure() throws BuildException {
//ProjectComponentHelper helper=ProjectComponentHelper.getProjectComponentHelper();
//realThing = helper.createProjectComponent( this, getProject(), null,
// this.getTag());
configure(makeObject(this, getWrapper()));
}
/**
* Configure the given object from this UnknownElement
*
* @param realObject the real object this UnknownElement is representing.
*
*/
public void configure(Object realObject) {
realThing = realObject;
getWrapper().setProxy(realThing);
Task task = null;
if (realThing instanceof Task) {
task = (Task) realThing;
task.setRuntimeConfigurableWrapper(getWrapper());
// For Script to work. Ugly
// The reference is replaced by RuntimeConfigurable
this.getOwningTarget().replaceChild(this, (Task) realThing);
}
handleChildren(realThing, getWrapper());
// configure attributes of the object and it's children. If it is
// a task container, defer the configuration till the task container
// attempts to use the task
if (task != null) {
task.maybeConfigure();
} else {
getWrapper().maybeConfigure(getProject());
}
}
/**
* Handles output sent to System.out by this task or its real task.
*
* @param output The output to log. Should not be null.
*/
protected void handleOutput(String output) {
if (realThing instanceof Task) {
((Task) realThing).handleOutput(output);
} else {
super.handleOutput(output);
}
}
/**
* @see Task#handleInput(byte[], int, int)
*
* @since Ant 1.6
*/
protected int handleInput(byte[] buffer, int offset, int length)
throws IOException {
if (realThing instanceof Task) {
return ((Task) realThing).handleInput(buffer, offset, length);
} else {
return super.handleInput(buffer, offset, length);
}
}
/**
* Handles output sent to System.out by this task or its real task.
*
* @param output The output to log. Should not be null.
*/
protected void handleFlush(String output) {
if (realThing instanceof Task) {
((Task) realThing).handleFlush(output);
} else {
super.handleFlush(output);
}
}
/**
* Handles error output sent to System.err by this task or its real task.
*
* @param output The error output to log. Should not be null.
*/
protected void handleErrorOutput(String output) {
if (realThing instanceof Task) {
((Task) realThing).handleErrorOutput(output);
} else {
super.handleErrorOutput(output);
}
}
/**
* Handles error output sent to System.err by this task or its real task.
*
* @param output The error output to log. Should not be null.
*/
protected void handleErrorFlush(String output) {
if (realThing instanceof Task) {
((Task) realThing).handleErrorOutput(output);
} else {
super.handleErrorOutput(output);
}
}
/**
* Executes the real object if it's a task. If it's not a task
* (e.g. a data type) then this method does nothing.
*/
public void execute() {
if (realThing == null) {
// plain impossible to get here, maybeConfigure should
// have thrown an exception.
throw new BuildException("Could not create task of type: "
+ elementName, getLocation());
}
if (realThing instanceof Task) {
((Task) realThing).execute();
}
// the task will not be reused ( a new init() will be called )
// Let GC do its job
realThing = null;
}
/**
* Adds a child element to this element.
*
* @param child The child element to add. Must not be null.
*/
public void addChild(UnknownElement child) {
if (children == null) {
children = new ArrayList();
}
children.add(child);
}
/**
* Creates child elements, creates children of the children
* (recursively), and sets attributes of the child elements.
*
* @param parent The configured object for the parent.
* Must not be null.
*
* @param parentWrapper The wrapper containing child wrappers
* to be configured. Must not be null
* if there are any children.
*
* @exception BuildException if the children cannot be configured.
*/
protected void handleChildren(
Object parent,
RuntimeConfigurable parentWrapper)
throws BuildException {
if (parent instanceof TypeAdapter) {
parent = ((TypeAdapter) parent).getProxy();
}
String parentUri = getNamespace();
Class parentClass = parent.getClass();
IntrospectionHelper ih = IntrospectionHelper.getHelper(parentClass);
if (children != null) {
Iterator it = children.iterator();
for (int i = 0; it.hasNext(); i++) {
RuntimeConfigurable childWrapper = parentWrapper.getChild(i);
UnknownElement child = (UnknownElement) it.next();
if (!handleChild(
parentUri, ih, parent, child, childWrapper)) {
if (!(parent instanceof TaskContainer)) {
ih.throwNotSupported(getProject(), parent,
child.getTag());
} else {
// a task container - anything could happen - just add the
// child to the container
TaskContainer container = (TaskContainer) parent;
container.addTask(child);
}
}
}
}
}
/**
* @return the component name - uses ProjectHelper#genComponentName()
*/
protected String getComponentName() {
return ProjectHelper.genComponentName(getNamespace(), getTag());
}
/**
* This is used then the realobject of the UE is a PreSetDefinition.
* This is also used when a presetdef is used on a presetdef
* The attributes, elements and text are applied to this
* UE.
*
* @param u an UnknownElement containing the attributes, elements and text
*/
public void applyPreSet(UnknownElement u) {
if (presetDefed) {
return;
}
// Do the runtime
getWrapper().applyPreSet(u.getWrapper());
if (u.children != null) {
List newChildren = new ArrayList();
newChildren.addAll(u.children);
if (children != null) {
newChildren.addAll(children);
}
children = newChildren;
}
presetDefed = true;
}
/**
* Creates a named task or data type. If the real object is a task,
* it is configured up to the init() stage.
*
* @param ue The unknown element to create the real object for.
* Must not be null.
* @param w Ignored in this implementation.
*
* @return the task or data type represented by the given unknown element.
*/
protected Object makeObject(UnknownElement ue, RuntimeConfigurable w) {
ComponentHelper helper = ComponentHelper.getComponentHelper(
getProject());
String name = ue.getComponentName();
Object o = helper.createComponent(ue, ue.getNamespace(), name);
if (o == null) {
throw getNotFoundException("task or type", name);
}
if (o instanceof PreSetDef.PreSetDefinition) {
PreSetDef.PreSetDefinition def = (PreSetDef.PreSetDefinition) o;
o = def.createObject(ue.getProject());
if (o == null) {
throw getNotFoundException(
"preset " + name,
def.getPreSets().getComponentName());
}
ue.applyPreSet(def.getPreSets());
if (o instanceof Task) {
Task task = (Task) o;
task.setTaskType(ue.getTaskType());
task.setTaskName(ue.getTaskName());
}
}
if (o instanceof Task) {
Task task = (Task) o;
task.setOwningTarget(getOwningTarget());
task.init();
}
return o;
}
/**
* Creates a named task and configures it up to the init() stage.
*
* @param ue The UnknownElement to create the real task for.
* Must not be null.
* @param w Ignored.
*
* @return the task specified by the given unknown element, or
* null if the task name is not recognised.
*/
protected Task makeTask(UnknownElement ue, RuntimeConfigurable w) {
Task task = getProject().createTask(ue.getTag());
if (task != null) {
task.setLocation(getLocation());
// UnknownElement always has an associated target
task.setOwningTarget(getOwningTarget());
task.init();
}
return task;
}
/**
* Returns a very verbose exception for when a task/data type cannot
* be found.
*
* @param what The kind of thing being created. For example, when
* a task name could not be found, this would be
* "task". Should not be null.
* @param elementName The name of the element which could not be found.
* Should not be null.
*
* @return a detailed description of what might have caused the problem.
*/
protected BuildException getNotFoundException(String what,
String elementName) {
String lSep = System.getProperty("line.separator");
String msg = "Could not create " + what + " of type: " + elementName
+ "." + lSep + lSep
+ "Ant could not find the task or a class this "
+ "task relies upon." + lSep + lSep
+ "This is common and has a number of causes; the usual " + lSep
+ "solutions are to read the manual pages then download and" + lSep
+ "install needed JAR files, or fix the build file: " + lSep
+ " - You have misspelt '" + elementName + "'." + lSep
+ " Fix: check your spelling." + lSep
+ " - The task needs an external JAR file to execute" + lSep
+ " and this is not found at the right place in the classpath." + lSep
+ " Fix: check the documentation for dependencies." + lSep
+ " Fix: declare the task." + lSep
+ " - The task is an Ant optional task and the JAR file and/or libraries" + lSep
+ " implementing the functionality were not found at the time you" + lSep
+ " yourself built your installation of Ant from the Ant sources." + lSep
+ " Fix: Look in the ANT_HOME/lib for the 'ant-' JAR corresponding to the" + lSep
+ " task and make sure it contains more than merely a META-INF/MANIFEST.MF." + lSep
+ " If all it contains is the manifest, then rebuild Ant with the needed" + lSep
+ " libraries present in ${ant.home}/lib/optional/ , or alternatively," + lSep
+ " download a pre-built release version from apache.org" + lSep
+ " - The build file was written for a later version of Ant" + lSep
+ " Fix: upgrade to at least the latest release version of Ant" + lSep
+ " - The task is not an Ant core or optional task " + lSep
+ " and needs to be declared using ." + lSep
+ " - You are attempting to use a task defined using " + lSep
+ " or but have spelt wrong or not " + lSep
+ " defined it at the point of use" + lSep
+ lSep
+ "Remember that for JAR files to be visible to Ant tasks implemented" + lSep
+ "in ANT_HOME/lib, the files must be in the same directory or on the" + lSep
+ "classpath" + lSep
+ lSep
+ "Please neither file bug reports on this problem, nor email the" + lSep
+ "Ant mailing lists, until all of these causes have been explored," + lSep
+ "as this is not an Ant bug.";
return new BuildException(msg, getLocation());
}
/**
* Returns the name to use in logging messages.
*
* @return the name to use in logging messages.
*/
public String getTaskName() {
//return elementName;
return realThing == null
|| !(realThing instanceof Task) ? super.getTaskName()
: ((Task) realThing).getTaskName();
}
/**
* Returns the task instance after it has been created and if it is a task.
*
* @return a task instance or null if the real object is not
* a task.
*/
public Task getTask() {
if (realThing instanceof Task) {
return (Task) realThing;
}
return null;
}
/**
* Return the configured object
*
* @return the real thing whatever it is
*
* @since ant 1.6
*/
public Object getRealThing() {
return realThing;
}
/**
* Try to create a nested element of parent for the
* given tag.
*
* @return whether the creation has been successful
*/
private boolean handleChild(
String parentUri,
IntrospectionHelper ih,
Object parent, UnknownElement child,
RuntimeConfigurable childWrapper) {
String childName = ProjectHelper.genComponentName(
child.getNamespace(), child.getTag());
if (ih.supportsNestedElement(parentUri, childName)) {
IntrospectionHelper.Creator creator =
ih.getElementCreator(
getProject(), parentUri, parent, childName, child);
creator.setPolyType(childWrapper.getPolyType());
Object realChild = creator.create();
if (realChild instanceof PreSetDef.PreSetDefinition) {
PreSetDef.PreSetDefinition def =
(PreSetDef.PreSetDefinition) realChild;
realChild = creator.getRealObject();
child.applyPreSet(def.getPreSets());
}
childWrapper.setCreator(creator);
childWrapper.setProxy(realChild);
if (realChild instanceof Task) {
Task childTask = (Task) realChild;
childTask.setRuntimeConfigurableWrapper(childWrapper);
childTask.setTaskName(childName);
childTask.setTaskType(childName);
childTask.setLocation(child.getLocation());
}
child.handleChildren(realChild, childWrapper);
return true;
}
return false;
}
/**
* like contents equals, but ignores project
* @param obj the object to check against
* @return true if this unknownelement has the same contents the other
*/
public boolean similar(Object obj) {
if (obj == null) {
return false;
}
if (!getClass().getName().equals(obj.getClass().getName())) {
return false;
}
UnknownElement other = (UnknownElement) obj;
// Are the names the same ?
if (!equalsString(elementName, other.elementName)) {
return false;
}
if (!namespace.equals(other.namespace)) {
return false;
}
if (!qname.equals(other.qname)) {
return false;
}
// Are attributes the same ?
if (!getWrapper().getAttributeMap().equals(
other.getWrapper().getAttributeMap())) {
return false;
}
// Is the text the same?
// Need to use equals on the string and not
// on the stringbuffer as equals on the string buffer
// does not compare the contents.
if (!getWrapper().getText().toString().equals(
other.getWrapper().getText().toString())) {
return false;
}
// Are the sub elements the same ?
if (children == null || children.size() == 0) {
return other.children == null || other.children.size() == 0;
}
if (other.children == null) {
return false;
}
if (children.size() != other.children.size()) {
return false;
}
for (int i = 0; i < children.size(); ++i) {
UnknownElement child = (UnknownElement) children.get(i);
if (!child.similar(other.children.get(i))) {
return false;
}
}
return true;
}
private boolean equalsString(String a, String b) {
if (a == null) {
return b == null;
}
return a.equals(b);
}
}