| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * Copyright (c) 2001 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 |
| * <http://www.apache.org/>. |
| */ |
| package org.apache.ant.core.execution; |
| |
| import org.apache.ant.core.model.*; |
| import org.apache.ant.core.support.*; |
| import org.apache.ant.core.types.*; |
| |
| import java.util.*; |
| import java.net.*; |
| |
| /** |
| * An ExecutionFrame is the state of a project during an execution. |
| * The ExecutionFrame contains the data values set by Ant tasks as |
| * they are executed, including task definitions, property values, etc. |
| * |
| * @author <a href="mailto:conor@apache.org">Conor MacNeill</a> |
| */ |
| public class ExecutionFrame { |
| /** State used in dependency analysis when a target's dependencies are being |
| examined. */ |
| private static final String VISITING = "VISITING"; |
| |
| /** State used in dependency analysis to indicate a target has been examined */ |
| private static final String VISITED = "VISITED"; |
| |
| /** The Project that this execiton frame is processing */ |
| private Project project = null; |
| |
| /** The base URL for this frame. This is derived from the |
| Project's source URL and it's base attribute. */ |
| private URL baseURL = null; |
| |
| /** The imported frames of this frame. For each project imported by this frame's |
| project, a corresponding ExecutionFrame is created. */ |
| private Map importedFrames = new HashMap(); |
| |
| /** BuildEvent support used to fire events and manage listeners */ |
| private BuildEventSupport eventSupport = new BuildEventSupport(); |
| |
| /** The context of this execution. This contains all data object's |
| created by tasks that have been executed */ |
| private Map dataValues = new HashMap(); |
| |
| /** Introspector objects used to configure Tasks from the Task models.*/ |
| private Map introspectors = new HashMap(); |
| |
| /** The task defs that this frame will use to process tasks */ |
| private Map taskDefs = new HashMap(); |
| |
| /** Type converters for this executionFrame. Converters are used when configuring |
| Tasks to handle special type conversions. */ |
| private Map converters = new HashMap(); |
| |
| /** The aspect handler active in this frame */ |
| private Map aspectHandlers = new HashMap(); |
| |
| /** The namespace under which this execution frame lives in the hierarchical |
| project namespace - null for the root namespace */ |
| private String namespace; |
| |
| /** |
| * Construct an execution frame to process the given project model with |
| * the configuration represented by the libraries. |
| * |
| * @param project the model of the project to be built. |
| * @param libraries an Array of AntLibrary objects containing the |
| * configuration of Ant for this build. |
| * |
| * @throws ConfigException when the project cannot be setup with the |
| * given configuration |
| */ |
| public ExecutionFrame(Project project, AntLibrary[] libraries) |
| throws ConfigException { |
| |
| this.namespace = null; |
| setupFrame(project, libraries); |
| } |
| |
| /** |
| * Construct a subframe for managing a project imported into the main project. |
| * @param project the model of the project to be built. |
| * @param libraries an Array of AntLibrary objects containing the |
| * configuration of Ant for this build. |
| * @param namespace the location of this project within the overall import |
| * namespace. |
| * |
| * @throws ConfigException when the project cannot be setup with the |
| * given configuration |
| */ |
| private ExecutionFrame(Project project, AntLibrary[] libraries, String namespace) |
| throws ConfigException { |
| |
| this.namespace = namespace; |
| setupFrame(project, libraries); |
| } |
| |
| |
| /** |
| * Set up the execution frame. |
| * |
| * This method examines the project model and constructs the required |
| * subframes to handle imported projects. |
| * @param project the model of the project to be built. |
| * @param libraries an Array of AntLibrary objects containing the |
| * configuration of Ant for this build. |
| * |
| * @throws ConfigException when the project cannot be setup with the |
| * given configuration |
| */ |
| private void setupFrame(Project project, AntLibrary[] libraries) |
| throws ConfigException { |
| |
| this.project = project; |
| for (int i = 0; i < libraries.length; ++i) { |
| addLibrary(libraries[i]); |
| } |
| |
| try { |
| String base = project.getBase(); |
| if (base == null) { |
| baseURL = project.getSourceURL(); |
| } |
| else { |
| base = base.trim(); |
| if (!base.endsWith("/")) { |
| base += "/"; |
| } |
| baseURL = new URL(project.getSourceURL(), base); |
| } |
| } |
| catch (MalformedURLException e) { |
| throw new ConfigException("Project's base value \"" + project.getBase() |
| + "\" is not valid", e, project.getLocation()); |
| } |
| |
| for (Iterator i = project.getImportedProjectNames(); i.hasNext();) { |
| String importName = (String)i.next(); |
| Project importedProject = project.getImportedProject(importName); |
| String importNamespace |
| = namespace == null ? importName : namespace + ":" + importName; |
| ExecutionFrame importedFrame |
| = new ExecutionFrame(importedProject, libraries, importNamespace); |
| importedFrames.put(importName, importedFrame); |
| } |
| } |
| |
| /** |
| * Add a configuration library to this execution frame. The library |
| * will contain task definitions, converters, apsect handler definitions, |
| * etc. |
| * |
| * @param library the configuration library to add to this frame. |
| * |
| * @throws ConfigException if the items in the library cannot be configured. |
| */ |
| public void addLibrary(AntLibrary library) throws ConfigException { |
| for (Iterator i = library.getTaskDefinitions(); i.hasNext(); ) { |
| TaskDefinition taskDefinition = (TaskDefinition)i.next(); |
| addTaskDefinition(taskDefinition); |
| } |
| for (Iterator i = library.getConverterDefinitions(); i.hasNext(); ) { |
| ConverterDefinition converterDef = (ConverterDefinition)i.next(); |
| addConverterDefinition(converterDef); |
| } |
| for (Iterator i = library.getAspectDefinitions(); i.hasNext(); ) { |
| AspectDefinition aspectDef = (AspectDefinition)i.next(); |
| addAspectHandler(aspectDef); |
| } |
| } |
| |
| /** |
| * Add a task definition to this execution frame |
| * |
| * @param taskDefinition the TaskDefinition to be added to the project. |
| */ |
| public void addTaskDefinition(TaskDefinition taskDefinition) { |
| String taskName = taskDefinition.getName(); |
| taskDefs.put(taskName, taskDefinition); |
| } |
| |
| /** |
| * Add a aspect handler definition to this execution frame |
| * |
| * @param taskDefinition the TaskDefinition to be added to the project. |
| * |
| * @throws ConfigException if the aspect handler cannot be created or configured. |
| */ |
| public void addAspectHandler(AspectDefinition aspectDefinition) |
| throws ConfigException { |
| String aspectPrefix = aspectDefinition.getAspectPrefix(); |
| try { |
| Class aspectHandlerClass = aspectDefinition.getAspectHandlerClass(); |
| aspectHandlers.put(aspectPrefix, aspectHandlerClass); |
| } |
| catch (ClassNotFoundException e) { |
| throw new ConfigException("Unable to load aspect handler class for " |
| + aspectDefinition.getAspectHandlerClassName() |
| + " in converter from " + aspectDefinition.getLibraryURL(), |
| e); |
| } |
| } |
| |
| /** |
| * Add a converter definition to this library. |
| * |
| * The converter is created immediately to handle conversions |
| * when items are being configured. If the converter is an instance of |
| * an AntConverter, the converter is configured with this execution |
| * frame giving it the context it needs to resolve items relative to the |
| * project's base, etc. |
| * |
| * @param converterDef the converter definition to load |
| * |
| * @throws ConfigException if the converter cannot be created or configured. |
| */ |
| public void addConverterDefinition(ConverterDefinition converterDef) throws ConfigException { |
| boolean targetLoaded = false; |
| try { |
| Class targetClass = converterDef.getTargetClass(); |
| targetLoaded = false; |
| Class converterClass = converterDef.getConverterClass(); |
| Converter converter = (AntConverter)converterClass.newInstance(); |
| if (converter instanceof AntConverter) { |
| ((AntConverter)converter).init(this); |
| } |
| converters.put(targetClass, converter); |
| } |
| catch (ClassNotFoundException e) { |
| if (targetLoaded) { |
| throw new ConfigException("Unable to load converter class for " |
| + converterDef.getConverterClassName() |
| + " in converter from " + converterDef.getLibraryURL(), |
| e); |
| } |
| else { |
| throw new ConfigException("Unable to load target class " |
| + converterDef.getTargetClassName() |
| + " in converter from " + converterDef.getLibraryURL(), |
| e); |
| } |
| } |
| catch (InstantiationException e) { |
| throw new ConfigException("Unable to instantiate converter class " |
| + converterDef.getTargetClassName() |
| + " in converter from " + converterDef.getLibraryURL(), |
| e); |
| } |
| catch (IllegalAccessException e) { |
| throw new ConfigException("Unable to access converter class " |
| + converterDef.getTargetClassName() |
| + " in converter from " + converterDef.getLibraryURL(), |
| e); |
| } |
| } |
| |
| |
| /** |
| * Get the bae URL of this frame. This will either be specified by the project's |
| * base attribute or be derived implicitly from the project's location. |
| */ |
| public URL getBaseURL() { |
| return baseURL; |
| } |
| |
| |
| public void addBuildListener(BuildListener listener) { |
| for (Iterator i = getImportedFrames(); i.hasNext(); ) { |
| ExecutionFrame subFrame = (ExecutionFrame)i.next(); |
| subFrame.addBuildListener(listener); |
| } |
| eventSupport.addBuildListener(listener); |
| } |
| |
| public void removeBuildListener(BuildListener listener) { |
| for (Iterator i = getImportedFrames(); i.hasNext(); ) { |
| ExecutionFrame subFrame = (ExecutionFrame)i.next(); |
| subFrame.removeBuildListener(listener); |
| } |
| eventSupport.removeBuildListener(listener); |
| } |
| |
| /** |
| * Get the project associated with this execution frame. |
| * |
| * @return the project associated iwth this execution frame. |
| */ |
| public Project getProject() { |
| return project; |
| } |
| |
| |
| /** |
| * Get the names of the frames representing imported projects. |
| * |
| * @return an iterator which returns the names of the imported frames. |
| */ |
| public Iterator getImportedFrameNames() { |
| return importedFrames.keySet().iterator(); |
| } |
| |
| |
| /** |
| * Get the frames representing imported projects. |
| * |
| * @return an iterator which returns the imported ExeuctionFrames.. |
| */ |
| public Iterator getImportedFrames() { |
| return importedFrames.values().iterator(); |
| } |
| |
| /** |
| * Get an imported frame by name |
| * |
| * @param importName the name under which the frame was imported. |
| * |
| * @return the ExecutionFrame asscociated with the given import name or null |
| * if there is no such project. |
| */ |
| public ExecutionFrame getImportedFrame(String importName) { |
| return (ExecutionFrame)importedFrames.get(importName); |
| } |
| |
| /** |
| * Get the location of this frame in the namespace hierarchy |
| * |
| * @return the location of this frame within the project import |
| * namespace hierarchy. |
| */ |
| public String getNamespace() { |
| return namespace; |
| } |
| |
| /** |
| * Get the fully qualified name of something with respect to this |
| * execution frame. |
| * |
| * @param name the unqualified name. |
| * |
| * @return the fully qualified version of the given name |
| */ |
| public String getQualifiedName(String name) { |
| return namespace == null ? name : namespace + ":" + name; |
| } |
| |
| /** |
| * Execute the given target's tasks |
| * |
| * @param the name of the target within this frame that is to be executed. |
| */ |
| public void executeTargetTasks(String targetName) throws ExecutionException, ConfigException { |
| Target target = project.getTarget(targetName); |
| try { |
| Iterator taskIterator = target.getTasks(); |
| eventSupport.fireTargetStarted(this, target); |
| executeTasks(taskIterator); |
| eventSupport.fireTargetFinished(this, target, null); |
| } |
| catch (RuntimeException e) { |
| eventSupport.fireTargetFinished(this, target, e); |
| throw e; |
| } |
| } |
| |
| /** |
| * Initialize the frame by executing the project level tasks if any |
| */ |
| public void initialize() throws ExecutionException, ConfigException { |
| for (Iterator i = getImportedFrames(); i.hasNext(); ) { |
| ExecutionFrame subFrame = (ExecutionFrame)i.next(); |
| subFrame.initialize(); |
| } |
| Iterator taskIterator = project.getTasks(); |
| executeTasks(taskIterator); |
| } |
| |
| public void fillinDependencyOrder(String targetName, List dependencyOrder, |
| Map state, Stack visiting) throws ConfigException { |
| String fullTargetName = getQualifiedName(targetName); |
| if (state.get(fullTargetName) == VISITED) { |
| return; |
| } |
| Target target = getProject().getTarget(targetName); |
| if (target == null) { |
| StringBuffer sb = new StringBuffer("Target `"); |
| sb.append(targetName); |
| sb.append("' does not exist in this project. "); |
| if (!visiting.empty()) { |
| String parent = (String)visiting.peek(); |
| sb.append("It is used from target `"); |
| sb.append(parent); |
| sb.append("'."); |
| } |
| |
| throw new ConfigException(new String(sb), getProject().getLocation()); |
| } |
| |
| state.put(fullTargetName, VISITING); |
| visiting.push(fullTargetName); |
| for (Iterator i = target.getDependencies(); i.hasNext(); ) { |
| String dependency = (String)i.next(); |
| try { |
| ExecutionFrame dependencyFrame = getRelativeFrame(dependency); |
| if (dependencyFrame == null) { |
| StringBuffer sb = new StringBuffer("Target `"); |
| sb.append(dependency); |
| sb.append("' does not exist in this project. "); |
| throw new ConfigException(new String(sb), target.getLocation()); |
| } |
| |
| String fullyQualifiedName = getQualifiedName(dependency); |
| String dependencyState = (String)state.get(fullyQualifiedName); |
| if (dependencyState == null) { |
| dependencyFrame.fillinDependencyOrder(getNameInFrame(dependency), dependencyOrder, |
| state, visiting); |
| } |
| else if (dependencyState == VISITING) { |
| String circleDescription |
| = getCircularDesc(dependency, visiting); |
| throw new ConfigException(circleDescription, target.getLocation()); |
| } |
| } |
| catch (ExecutionException e) { |
| throw new ConfigException(e.getMessage(), e, target.getLocation()); |
| } |
| } |
| |
| state.put(fullTargetName, VISITED); |
| String poppedNode = (String)visiting.pop(); |
| if (poppedNode != fullTargetName) { |
| throw new ConfigException("Problem determining dependencies " + |
| " - expecting '" + fullTargetName + |
| "' but got '" + poppedNode + "'"); |
| } |
| dependencyOrder.add(fullTargetName); |
| } |
| |
| private String getCircularDesc(String end, Stack visitingNodes) { |
| StringBuffer sb = new StringBuffer("Circular dependency: "); |
| sb.append(end); |
| String c; |
| do { |
| c = (String)visitingNodes.pop(); |
| sb.append(" <- "); |
| sb.append(c); |
| } while(!c.equals(end)); |
| return new String(sb); |
| } |
| |
| /** |
| * Check whether the targets in this frame and its subframes are OK |
| */ |
| public void checkTargets(List dependencyOrder, Map state, Stack visiting) |
| throws ConfigException { |
| // get the targets and just iterate through them. |
| for (Iterator i = getProject().getTargets(); i.hasNext();) { |
| Target target = (Target)i.next(); |
| fillinDependencyOrder(target.getName(), |
| dependencyOrder, state, visiting); |
| } |
| |
| // Now do the subframes. |
| for (Iterator i = getImportedFrames(); i.hasNext();) { |
| ExecutionFrame importedFrame = (ExecutionFrame)i.next(); |
| importedFrame.checkTargets(dependencyOrder, state, visiting); |
| } |
| } |
| |
| |
| /** |
| * Create a Task and configure it according to the given model. |
| */ |
| private Task configureTask(TaskElement model) |
| throws ConfigException, ExecutionException { |
| |
| String taskType = model.getType(); |
| TaskDefinition taskDefinition = (TaskDefinition)taskDefs.get(taskType); |
| if (taskDefinition == null) { |
| throw new ConfigException("There is no defintion for tasks of type <" |
| + taskType + ">", model.getLocation()); |
| } |
| |
| try { |
| Class elementClass = taskDefinition.getExecutionTaskClass(); |
| Object element = elementClass.newInstance(); |
| Task task = null; |
| if (element instanceof Task) { |
| // create a Task context for the Task |
| task = (Task)element; |
| } |
| else { |
| task = new TaskAdapter(taskType, element); |
| } |
| |
| configureElement(element, model); |
| |
| return task; |
| } |
| catch (ClassNotFoundException e) { |
| throw new ConfigException("Execution class " + taskDefinition.getTaskClassName() |
| + " was not found", e, model.getLocation()); |
| } |
| catch (InstantiationException e) { |
| throw new ConfigException("Unable to instantiate execution class " |
| + taskDefinition.getTaskClassName(), |
| e, model.getLocation()); |
| } |
| catch (IllegalAccessException e) { |
| throw new ConfigException("Unable to access execution class " |
| + taskDefinition.getTaskClassName(), |
| e, model.getLocation()); |
| } |
| } |
| |
| private List getActiveAspects(BuildElement model) |
| throws ConfigException, ExecutionException, |
| ClassIntrospectionException, ConversionException { |
| List activeAspects = new ArrayList(); |
| for (Iterator i = model.getAspectNames(); i.hasNext();) { |
| String aspectPrefix = (String)i.next(); |
| Class aspectHandlerClass = (Class)aspectHandlers.get(aspectPrefix); |
| if (aspectHandlerClass != null) { |
| try { |
| AspectHandler aspectHandler |
| = (AspectHandler)aspectHandlerClass.newInstance(); |
| ClassIntrospector introspector = getIntrospector(aspectHandlerClass); |
| |
| ExecutionContext context = new ExecutionContext(this, eventSupport, model); |
| aspectHandler.setAspectContext(context); |
| |
| Map aspectAttributes = model.getAspectAttributes(aspectPrefix); |
| for (Iterator j = aspectAttributes.keySet().iterator(); j.hasNext();) { |
| String attributeName = (String)j.next(); |
| String attributeValue = (String)aspectAttributes.get(attributeName); |
| introspector.setAttribute(aspectHandler, attributeName, |
| replacePropertyRefs(attributeValue)); |
| } |
| activeAspects.add(aspectHandler); |
| } |
| catch (InstantiationException e) { |
| throw new ConfigException("Unable to instantiate aspect handler class " |
| + aspectHandlerClass, |
| e); |
| } |
| catch (IllegalAccessException e) { |
| throw new ConfigException("Unable to access aspect handler class " |
| + aspectHandlerClass, |
| e); |
| } |
| } |
| } |
| return activeAspects; |
| } |
| |
| |
| /** |
| * Configure an element according to the given model. |
| */ |
| private void configureElement(Object element, TaskElement model) |
| throws ExecutionException, ConfigException { |
| |
| if (element instanceof Task) { |
| Task task = (Task)element; |
| ExecutionContext context = new ExecutionContext(this, eventSupport, model); |
| task.setTaskContext(context); |
| } |
| try { |
| ClassIntrospector introspector = getIntrospector(element.getClass()); |
| |
| List aspects = getActiveAspects(model); |
| for (Iterator i = aspects.iterator(); i.hasNext(); ) { |
| AspectHandler aspectHandler = (AspectHandler)i.next(); |
| aspectHandler.beforeConfigElement(element); |
| } |
| |
| // start by setting the attributes of this element |
| for (Iterator i = model.getAttributeNames(); i.hasNext();) { |
| String attributeName = (String)i.next(); |
| String attributeValue = model.getAttributeValue(attributeName); |
| introspector.setAttribute(element, attributeName, |
| replacePropertyRefs(attributeValue)); |
| } |
| |
| String modelText = model.getText().trim(); |
| if (modelText.length() != 0) { |
| introspector.addText(element, replacePropertyRefs(modelText)); |
| } |
| |
| // now do the nested elements |
| for (Iterator i = model.getNestedElements(); i.hasNext();) { |
| TaskElement nestedElementModel = (TaskElement)i.next(); |
| if (element instanceof TaskContainer && |
| !introspector.supportsNestedElement(nestedElementModel.getType())) { |
| |
| Task nestedTask = configureTask(nestedElementModel); |
| TaskContainer container = (TaskContainer)element; |
| container.addTask(nestedTask); |
| } |
| else { |
| Object nestedElement |
| = introspector.createElement(element, nestedElementModel.getType()); |
| configureElement(nestedElement, nestedElementModel); |
| } |
| } |
| for (Iterator i = aspects.iterator(); i.hasNext(); ) { |
| AspectHandler aspectHandler = (AspectHandler)i.next(); |
| aspectHandler.afterConfigElement(element); |
| } |
| } |
| catch (ClassIntrospectionException e) { |
| throw new ExecutionException(e, model.getLocation()); |
| } |
| catch (ConversionException e) { |
| throw new ExecutionException(e, model.getLocation()); |
| } |
| } |
| |
| /** |
| * Run the tasks returned by the give iterator |
| * |
| * @param taskIterator the iterator giving the tasks to execute |
| */ |
| public void executeTasks(Iterator taskIterator) throws ExecutionException, ConfigException { |
| TaskElement task = null; |
| try { |
| while (taskIterator.hasNext()) { |
| task = (TaskElement)taskIterator.next(); |
| try { |
| Task configuredTask = configureTask(task); |
| eventSupport.fireTaskStarted(this, task); |
| configuredTask.execute(); |
| } |
| catch (ExecutionException e) { |
| if (e.getLocation() == null || e.getLocation() == Location.UNKNOWN_LOCATION) { |
| e.setLocation(task.getLocation()); |
| } |
| throw e; |
| } |
| catch (ConfigException e) { |
| if (e.getLocation() == null || e.getLocation() == Location.UNKNOWN_LOCATION) { |
| e.setLocation(task.getLocation()); |
| } |
| throw e; |
| } |
| eventSupport.fireTaskFinished(this, task, null); |
| } |
| } |
| catch (RuntimeException e) { |
| eventSupport.fireTaskFinished(this, task, e); |
| throw e; |
| } |
| } |
| |
| private ClassIntrospector getIntrospector(Class c) { |
| if (introspectors.containsKey(c)) { |
| return (ClassIntrospector)introspectors.get(c); |
| } |
| ClassIntrospector introspector = new ClassIntrospector(c, converters); |
| introspectors.put(c, introspector); |
| return introspector; |
| } |
| |
| /** |
| * Replace ${} 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. |
| */ |
| public String replacePropertyRefs(String value) throws ExecutionException { |
| if (value == null) { |
| return null; |
| } |
| |
| List fragments = new ArrayList(); |
| List propertyRefs = new ArrayList(); |
| parsePropertyString(value, fragments, propertyRefs); |
| |
| StringBuffer sb = new StringBuffer(); |
| Iterator i = fragments.iterator(); |
| Iterator j = propertyRefs.iterator(); |
| while (i.hasNext()) { |
| String fragment = (String)i.next(); |
| if (fragment == null) { |
| String propertyName = (String)j.next(); |
| if (!isDataValueSet(propertyName)) { |
| throw new ExecutionException("Property " + propertyName + " has not been set"); |
| } |
| fragment = getDataValue(propertyName).toString(); |
| } |
| sb.append(fragment); |
| } |
| |
| return sb.toString(); |
| } |
| |
| |
| /** |
| * This method will parse a string containing ${value} style |
| * property values into two list. The first list is a collection |
| * of text fragments, while the other is a set of string property names |
| * null entries in the first list indicate a property reference from the |
| * second list. |
| */ |
| static public void parsePropertyString(String value, List fragments, List propertyRefs) |
| throws ExecutionException { |
| int prev = 0; |
| int pos; |
| while ((pos = value.indexOf("$", prev)) >= 0) { |
| if (pos > 0) { |
| fragments.add(value.substring(prev, pos)); |
| } |
| |
| if( pos == (value.length() - 1)) { |
| fragments.add("$"); |
| prev = pos + 1; |
| } |
| else if (value.charAt(pos + 1) != '{' ) { |
| fragments.add(value.substring(pos + 1, pos + 2)); |
| prev = pos + 2; |
| } else { |
| int endName = value.indexOf('}', pos); |
| if (endName < 0) { |
| throw new ExecutionException("Syntax error in property: " |
| + value ); |
| } |
| String propertyName = value.substring(pos + 2, endName); |
| fragments.add(null); |
| propertyRefs.add(propertyName); |
| prev = endName + 1; |
| } |
| } |
| |
| if (prev < value.length()) { |
| fragments.add(value.substring(prev)); |
| } |
| } |
| |
| /** |
| * Given a name of an object, get the frame relative from this frame that |
| * contains that object. |
| */ |
| public ExecutionFrame getRelativeFrame(String name) throws ExecutionException { |
| int index = name.lastIndexOf(":"); |
| if (index == -1) { |
| return this; |
| } |
| |
| ExecutionFrame currentFrame = this; |
| String relativeFrameName = name.substring(0, index); |
| StringTokenizer tokenizer = new StringTokenizer(relativeFrameName, ":"); |
| while (tokenizer.hasMoreTokens()) { |
| String frameName = tokenizer.nextToken(); |
| currentFrame = currentFrame.getImportedFrame(frameName); |
| if (currentFrame == null) { |
| throw new ExecutionException("The project " + frameName + " in " |
| + name + " was not found"); |
| } |
| } |
| |
| return currentFrame; |
| } |
| |
| /** |
| * Get the name of an object in its frame |
| */ |
| public String getNameInFrame(String name) { |
| int index = name.lastIndexOf(":"); |
| if (index == -1) { |
| return name; |
| } |
| return name.substring(index+1); |
| } |
| |
| /** |
| * Set a value in this frame or any of its imported frames |
| */ |
| public void setDataValue(String name, Object value) throws ExecutionException { |
| ExecutionFrame frame = getRelativeFrame(name); |
| frame.setDirectDataValue(getNameInFrame(name), value); |
| } |
| |
| /** |
| * Get a value from this frame or any imported frame |
| */ |
| public Object getDataValue(String name) throws ExecutionException { |
| ExecutionFrame frame = getRelativeFrame(name); |
| return frame.getDirectDataValue(getNameInFrame(name)); |
| } |
| |
| /** |
| * Set a value in this frame only |
| */ |
| private void setDirectDataValue(String name, Object value) { |
| dataValues.put(name, value); |
| } |
| |
| /** |
| * Get a value from this frame |
| */ |
| private Object getDirectDataValue(String name) { |
| return dataValues.get(name); |
| } |
| |
| /** |
| * Indicate if a data value has been set |
| */ |
| public boolean isDataValueSet(String name) throws ExecutionException { |
| ExecutionFrame frame = getRelativeFrame(name); |
| return frame.isDirectDataValueSet(getNameInFrame(name)); |
| } |
| |
| /** |
| * Indicate if a data value has been set in this frame |
| */ |
| private boolean isDirectDataValueSet(String name) { |
| return dataValues.containsKey(name); |
| } |
| |
| public void runBuild(List targetNames) throws AntException { |
| Throwable buildFailureCause = null; |
| try { |
| eventSupport.fireBuildStarted(this, project); |
| initialize(); |
| |
| if (targetNames.isEmpty()) { |
| // we just execute the default target if any |
| String defaultTarget = project.getDefaultTarget(); |
| if (defaultTarget != null) { |
| executeTarget(defaultTarget); |
| } |
| } |
| else { |
| for (Iterator i = targetNames.iterator(); i.hasNext();) { |
| executeTarget((String)i.next()); |
| } |
| } |
| eventSupport.fireBuildFinished(this, project, null); |
| } |
| catch (RuntimeException e) { |
| buildFailureCause = e; |
| throw e; |
| } |
| catch (AntException e) { |
| buildFailureCause = e; |
| throw e; |
| } |
| finally { |
| eventSupport.fireBuildFinished(this, project, buildFailureCause); |
| } |
| } |
| |
| public void executeTarget(String targetName) throws ExecutionException, ConfigException { |
| // to execute a target we must determine its dependencies and |
| // execute them in order. |
| Map state = new HashMap(); |
| Stack visiting = new Stack(); |
| List dependencyOrder = new ArrayList(); |
| ExecutionFrame startingFrame = getRelativeFrame(targetName); |
| startingFrame.fillinDependencyOrder(getNameInFrame(targetName), |
| dependencyOrder, state, visiting); |
| |
| // Now tell each frame to execute the targets required |
| for (Iterator i = dependencyOrder.iterator(); i.hasNext();) { |
| String fullTargetName = (String)i.next(); |
| ExecutionFrame frame = getRelativeFrame(fullTargetName); |
| frame.executeTargetTasks(getNameInFrame(fullTargetName)); |
| } |
| } |
| } |
