/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 == null ? "" : 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; // FIXME: the following should be done as well, but is // commented out for the moment as the unit tests fail // if it is done //getWrapper().setProxy(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(getProject(), 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(); try { 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); } } } catch (UnsupportedElementException ex) { throw new BuildException( parentWrapper.getElementTag() + " doesn't support the nested \"" + ex.getElement() + "\" element.", ex); } } } } /** * @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()); task.init(); } } if (o instanceof UnknownElement) { o = ((UnknownElement) o).makeObject((UnknownElement) o, w); } if (o instanceof Task) { ((Task) o).setOwningTarget(getOwningTarget()); } 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 name 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 name) { ComponentHelper helper = ComponentHelper.getComponentHelper(getProject()); String msg = helper.diagnoseCreationFailure(name, what); 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; } /** * Set the configured object * @param realThing the configured object * @since ant 1.7 */ public void setRealThing(Object realThing) { this.realThing = 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 static boolean equalsString(String a, String b) { return (a == null) ? (b == null) : a.equals(b); } }