Save This Page
Home » apache-ant-1.8.1 » org.apache.tools » ant » taskdefs » [javadoc | source]
    1   /*
    2    *  Licensed to the Apache Software Foundation (ASF) under one or more
    3    *  contributor license agreements.  See the NOTICE file distributed with
    4    *  this work for additional information regarding copyright ownership.
    5    *  The ASF licenses this file to You under the Apache License, Version 2.0
    6    *  (the "License"); you may not use this file except in compliance with
    7    *  the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
   10    *
   11    *  Unless required by applicable law or agreed to in writing, software
   12    *  distributed under the License is distributed on an "AS IS" BASIS,
   13    *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   14    *  See the License for the specific language governing permissions and
   15    *  limitations under the License.
   16    *
   17    */
   18   
   19   package org.apache.tools.ant.taskdefs;
   20   
   21   import java.io.File;
   22   import java.io.FileOutputStream;
   23   import java.io.IOException;
   24   import java.io.PrintStream;
   25   import java.lang.reflect.Method;
   26   import java.util.Enumeration;
   27   import java.util.Hashtable;
   28   import java.util.Iterator;
   29   import java.util.Vector;
   30   import java.util.Set;
   31   import java.util.HashSet;
   32   import org.apache.tools.ant.BuildException;
   33   import org.apache.tools.ant.BuildListener;
   34   import org.apache.tools.ant.DefaultLogger;
   35   import org.apache.tools.ant.Project;
   36   import org.apache.tools.ant.ProjectComponent;
   37   import org.apache.tools.ant.ProjectHelper;
   38   import org.apache.tools.ant.Target;
   39   import org.apache.tools.ant.Task;
   40   import org.apache.tools.ant.MagicNames;
   41   import org.apache.tools.ant.Main;
   42   import org.apache.tools.ant.types.PropertySet;
   43   import org.apache.tools.ant.util.FileUtils;
   44   import org.apache.tools.ant.util.VectorSet;
   45   
   46   /**
   47    * Build a sub-project.
   48    *
   49    *  <pre>
   50    *  &lt;target name=&quot;foo&quot; depends=&quot;init&quot;&gt;
   51    *    &lt;ant antfile=&quot;build.xml&quot; target=&quot;bar&quot; &gt;
   52    *      &lt;property name=&quot;property1&quot; value=&quot;aaaaa&quot; /&gt;
   53    *      &lt;property name=&quot;foo&quot; value=&quot;baz&quot; /&gt;
   54    *    &lt;/ant&gt;</span>
   55    *  &lt;/target&gt;</span>
   56    *
   57    *  &lt;target name=&quot;bar&quot; depends=&quot;init&quot;&gt;
   58    *    &lt;echo message=&quot;prop is ${property1} ${foo}&quot; /&gt;
   59    *  &lt;/target&gt;
   60    * </pre>
   61    *
   62    *
   63    * @since Ant 1.1
   64    *
   65    * @ant.task category="control"
   66    */
   67   public class Ant extends Task {
   68   
   69       private static final FileUtils FILE_UTILS = FileUtils.getFileUtils();
   70   
   71       /** the basedir where is executed the build file */
   72       private File dir = null;
   73   
   74       /**
   75        * the build.xml file (can be absolute) in this case dir will be
   76        * ignored
   77        */
   78       private String antFile = null;
   79   
   80       /** the output */
   81       private String output = null;
   82   
   83       /** should we inherit properties from the parent ? */
   84       private boolean inheritAll = true;
   85   
   86       /** should we inherit references from the parent ? */
   87       private boolean inheritRefs = false;
   88   
   89       /** the properties to pass to the new project */
   90       private Vector properties = new Vector();
   91   
   92       /** the references to pass to the new project */
   93       private Vector references = new Vector();
   94   
   95       /** the temporary project created to run the build file */
   96       private Project newProject;
   97   
   98       /** The stream to which output is to be written. */
   99       private PrintStream out = null;
  100   
  101       /** the sets of properties to pass to the new project */
  102       private Vector propertySets = new Vector();
  103   
  104       /** the targets to call on the new project */
  105       private Vector targets = new Vector();
  106   
  107       /** whether the target attribute was specified **/
  108       private boolean targetAttributeSet = false;
  109   
  110       /**
  111        * Whether the basedir of the new project should be the same one
  112        * as it would be when running the build file directly -
  113        * independent of dir and/or inheritAll settings.
  114        *
  115        * @since Ant 1.8.0
  116        */
  117       private boolean useNativeBasedir = false;
  118   
  119       /**
  120        * simple constructor
  121        */
  122       public Ant() {
  123           //default
  124       }
  125   
  126       /**
  127        * create a task bound to its creator
  128        * @param owner owning task
  129        */
  130       public Ant(Task owner) {
  131           bindToOwner(owner);
  132       }
  133   
  134       /**
  135        * Whether the basedir of the new project should be the same one
  136        * as it would be when running the build file directly -
  137        * independent of dir and/or inheritAll settings.
  138        *
  139        * @since Ant 1.8.0
  140        */
  141       public void setUseNativeBasedir(boolean b) {
  142           useNativeBasedir = b;
  143       }
  144   
  145       /**
  146        * If true, pass all properties to the new Ant project.
  147        * Defaults to true.
  148        * @param value if true pass all properties to the new Ant project.
  149        */
  150       public void setInheritAll(boolean value) {
  151           inheritAll = value;
  152       }
  153   
  154       /**
  155        * If true, pass all references to the new Ant project.
  156        * Defaults to false.
  157        * @param value if true, pass all references to the new Ant project
  158        */
  159       public void setInheritRefs(boolean value) {
  160           inheritRefs = value;
  161       }
  162   
  163       /**
  164        * Creates a Project instance for the project to call.
  165        */
  166       public void init() {
  167           newProject = getProject().createSubProject();
  168           newProject.setJavaVersionProperty();
  169       }
  170   
  171       /**
  172        * Called in execute or createProperty (via getNewProject())
  173        * if newProject is null.
  174        *
  175        * <p>This can happen if the same instance of this task is run
  176        * twice as newProject is set to null at the end of execute (to
  177        * save memory and help the GC).</p>
  178        * <p>calls init() again</p>
  179        *
  180        */
  181       private void reinit() {
  182           init();
  183       }
  184   
  185       /**
  186        * Attaches the build listeners of the current project to the new
  187        * project, configures a possible logfile, transfers task and
  188        * data-type definitions, transfers properties (either all or just
  189        * the ones specified as user properties to the current project,
  190        * depending on inheritall), transfers the input handler.
  191        */
  192       private void initializeProject() {
  193           newProject.setInputHandler(getProject().getInputHandler());
  194   
  195           Iterator iter = getBuildListeners();
  196           while (iter.hasNext()) {
  197               newProject.addBuildListener((BuildListener) iter.next());
  198           }
  199   
  200           if (output != null) {
  201               File outfile = null;
  202               if (dir != null) {
  203                   outfile = FILE_UTILS.resolveFile(dir, output);
  204               } else {
  205                   outfile = getProject().resolveFile(output);
  206               }
  207               try {
  208                   out = new PrintStream(new FileOutputStream(outfile));
  209                   DefaultLogger logger = new DefaultLogger();
  210                   logger.setMessageOutputLevel(Project.MSG_INFO);
  211                   logger.setOutputPrintStream(out);
  212                   logger.setErrorPrintStream(out);
  213                   newProject.addBuildListener(logger);
  214               } catch (IOException ex) {
  215                   log("Ant: Can't set output to " + output);
  216               }
  217           }
  218           // set user-defined properties
  219           if (useNativeBasedir) {
  220               addAlmostAll(getProject().getUserProperties(), PropertyType.USER);
  221           } else {
  222               getProject().copyUserProperties(newProject);
  223           }
  224   
  225           if (!inheritAll) {
  226              // set Ant's built-in properties separately,
  227              // because they are not being inherited.
  228              newProject.initProperties();
  229   
  230           } else {
  231               // set all properties from calling project
  232               addAlmostAll(getProject().getProperties(), PropertyType.PLAIN);
  233           }
  234   
  235           Enumeration e = propertySets.elements();
  236           while (e.hasMoreElements()) {
  237               PropertySet ps = (PropertySet) e.nextElement();
  238               addAlmostAll(ps.getProperties(), PropertyType.PLAIN);
  239           }
  240       }
  241   
  242       /**
  243        * Handles output.
  244        * Send it the the new project if is present, otherwise
  245        * call the super class.
  246        * @param outputToHandle The string output to output.
  247        * @see Task#handleOutput(String)
  248        * @since Ant 1.5
  249        */
  250       public void handleOutput(String outputToHandle) {
  251           if (newProject != null) {
  252               newProject.demuxOutput(outputToHandle, false);
  253           } else {
  254               super.handleOutput(outputToHandle);
  255           }
  256       }
  257   
  258       /**
  259        * Handles input.
  260        * Deleate to the created project, if present, otherwise
  261        * call the super class.
  262        * @param buffer the buffer into which data is to be read.
  263        * @param offset the offset into the buffer at which data is stored.
  264        * @param length the amount of data to read.
  265        *
  266        * @return the number of bytes read.
  267        *
  268        * @exception IOException if the data cannot be read.
  269        * @see Task#handleInput(byte[], int, int)
  270        * @since Ant 1.6
  271        */
  272       public int handleInput(byte[] buffer, int offset, int length)
  273           throws IOException {
  274           if (newProject != null) {
  275               return newProject.demuxInput(buffer, offset, length);
  276           }
  277           return super.handleInput(buffer, offset, length);
  278       }
  279   
  280       /**
  281        * Handles output.
  282        * Send it the the new project if is present, otherwise
  283        * call the super class.
  284        * @param toFlush The string to output.
  285        * @see Task#handleFlush(String)
  286        * @since Ant 1.5.2
  287        */
  288       public void handleFlush(String toFlush) {
  289           if (newProject != null) {
  290               newProject.demuxFlush(toFlush, false);
  291           } else {
  292               super.handleFlush(toFlush);
  293           }
  294       }
  295   
  296       /**
  297        * Handle error output.
  298        * Send it the the new project if is present, otherwise
  299        * call the super class.
  300        * @param errorOutputToHandle The string to output.
  301        *
  302        * @see Task#handleErrorOutput(String)
  303        * @since Ant 1.5
  304        */
  305       public void handleErrorOutput(String errorOutputToHandle) {
  306           if (newProject != null) {
  307               newProject.demuxOutput(errorOutputToHandle, true);
  308           } else {
  309               super.handleErrorOutput(errorOutputToHandle);
  310           }
  311       }
  312   
  313       /**
  314        * Handle error output.
  315        * Send it the the new project if is present, otherwise
  316        * call the super class.
  317        * @param errorOutputToFlush The string to output.
  318        * @see Task#handleErrorFlush(String)
  319        * @since Ant 1.5.2
  320        */
  321       public void handleErrorFlush(String errorOutputToFlush) {
  322           if (newProject != null) {
  323               newProject.demuxFlush(errorOutputToFlush, true);
  324           } else {
  325               super.handleErrorFlush(errorOutputToFlush);
  326           }
  327       }
  328   
  329       /**
  330        * Do the execution.
  331        * @throws BuildException if a target tries to call itself;
  332        * probably also if a BuildException is thrown by the new project.
  333        */
  334       public void execute() throws BuildException {
  335           File savedDir = dir;
  336           String savedAntFile = antFile;
  337           Vector locals = new VectorSet(targets);
  338           try {
  339               getNewProject();
  340   
  341               if (dir == null && inheritAll) {
  342                   dir = getProject().getBaseDir();
  343               }
  344   
  345               initializeProject();
  346   
  347               if (dir != null) {
  348                   if (!useNativeBasedir) {
  349                       newProject.setBaseDir(dir);
  350                       if (savedDir != null) {
  351                           // has been set explicitly
  352                           newProject.setInheritedProperty(MagicNames.PROJECT_BASEDIR,
  353                                                           dir.getAbsolutePath());
  354                       }
  355                   }
  356               } else {
  357                   dir = getProject().getBaseDir();
  358               }
  359   
  360               overrideProperties();
  361   
  362               if (antFile == null) {
  363                   antFile = getDefaultBuildFile();
  364               }
  365   
  366               File file = FILE_UTILS.resolveFile(dir, antFile);
  367               antFile = file.getAbsolutePath();
  368   
  369               log("calling target(s) "
  370                   + ((locals.size() > 0) ? locals.toString() : "[default]")
  371                   + " in build file " + antFile, Project.MSG_VERBOSE);
  372               newProject.setUserProperty(MagicNames.ANT_FILE , antFile);
  373   
  374               String thisAntFile = getProject().getProperty(MagicNames.ANT_FILE);
  375               // Are we trying to call the target in which we are defined (or
  376               // the build file if this is a top level task)?
  377               if (thisAntFile != null
  378                   && file.equals(getProject().resolveFile(thisAntFile))
  379                   && getOwningTarget() != null) {
  380   
  381                   if (getOwningTarget().getName().equals("")) {
  382                       if (getTaskName().equals("antcall")) {
  383                           throw new BuildException("antcall must not be used at"
  384                                                    + " the top level.");
  385                       }
  386                       throw new BuildException(getTaskName() + " task at the"
  387                                   + " top level must not invoke"
  388                                   + " its own build file.");
  389                   }
  390               }
  391   
  392               try {
  393                   ProjectHelper.configureProject(newProject, file);
  394               } catch (BuildException ex) {
  395                   throw ProjectHelper.addLocationToBuildException(
  396                       ex, getLocation());
  397               }
  398   
  399               if (locals.size() == 0) {
  400                   String defaultTarget = newProject.getDefaultTarget();
  401                   if (defaultTarget != null) {
  402                       locals.add(defaultTarget);
  403                   }
  404               }
  405   
  406               if (newProject.getProperty(MagicNames.ANT_FILE)
  407                   .equals(getProject().getProperty(MagicNames.ANT_FILE))
  408                   && getOwningTarget() != null) {
  409   
  410                   String owningTargetName = getOwningTarget().getName();
  411   
  412                   if (locals.contains(owningTargetName)) {
  413                       throw new BuildException(getTaskName() + " task calling "
  414                                                + "its own parent target.");
  415                   }
  416                   boolean circular = false;
  417                   for (Iterator it = locals.iterator();
  418                        !circular && it.hasNext();) {
  419                       Target other =
  420                           (Target) (getProject().getTargets().get(it.next()));
  421                       circular |= (other != null
  422                                    && other.dependsOn(owningTargetName));
  423                   }
  424                   if (circular) {
  425                       throw new BuildException(getTaskName()
  426                                                + " task calling a target"
  427                                                + " that depends on"
  428                                                + " its parent target \'"
  429                                                + owningTargetName
  430                                                + "\'.");
  431                   }
  432               }
  433   
  434               addReferences();
  435   
  436               if (locals.size() > 0 && !(locals.size() == 1
  437                                          && "".equals(locals.get(0)))) {
  438                   BuildException be = null;
  439                   try {
  440                       log("Entering " + antFile + "...", Project.MSG_VERBOSE);
  441                       newProject.fireSubBuildStarted();
  442                       newProject.executeTargets(locals);
  443                   } catch (BuildException ex) {
  444                       be = ProjectHelper
  445                           .addLocationToBuildException(ex, getLocation());
  446                       throw be;
  447                   } finally {
  448                       log("Exiting " + antFile + ".", Project.MSG_VERBOSE);
  449                       newProject.fireSubBuildFinished(be);
  450                   }
  451               }
  452           } finally {
  453               // help the gc
  454               newProject = null;
  455               Enumeration e = properties.elements();
  456               while (e.hasMoreElements()) {
  457                   Property p = (Property) e.nextElement();
  458                   p.setProject(null);
  459               }
  460   
  461               if (output != null && out != null) {
  462                   try {
  463                       out.close();
  464                   } catch (final Exception ex) {
  465                       //ignore
  466                   }
  467               }
  468               dir = savedDir;
  469               antFile = savedAntFile;
  470           }
  471       }
  472   
  473       /**
  474        * Get the default build file name to use when launching the task.
  475        * <p>
  476        * This function may be overrided by providers of custom ProjectHelper so they can implement easily their sub
  477        * launcher.
  478        * 
  479        * @return the name of the default file
  480        * @since Ant 1.8.0
  481        */
  482       protected String getDefaultBuildFile() {
  483           return Main.DEFAULT_BUILD_FILENAME;
  484       }
  485   
  486       /**
  487        * Override the properties in the new project with the one
  488        * explicitly defined as nested elements here.
  489        * @throws BuildException under unknown circumstances.
  490        */
  491       private void overrideProperties() throws BuildException {
  492           // remove duplicate properties - last property wins
  493           // Needed for backward compatibility
  494           Set set = new HashSet();
  495           for (int i = properties.size() - 1; i >= 0; --i) {
  496               Property p = (Property) properties.get(i);
  497               if (p.getName() != null && !p.getName().equals("")) {
  498                   if (set.contains(p.getName())) {
  499                       properties.remove(i);
  500                   } else {
  501                       set.add(p.getName());
  502                   }
  503               }
  504           }
  505           Enumeration e = properties.elements();
  506           while (e.hasMoreElements()) {
  507               Property p = (Property) e.nextElement();
  508               p.setProject(newProject);
  509               p.execute();
  510           }
  511           if (useNativeBasedir) {
  512               addAlmostAll(getProject().getInheritedProperties(),
  513                            PropertyType.INHERITED);
  514           } else {
  515               getProject().copyInheritedProperties(newProject);
  516           }
  517       }
  518   
  519       /**
  520        * Add the references explicitly defined as nested elements to the
  521        * new project.  Also copy over all references that don't override
  522        * existing references in the new project if inheritrefs has been
  523        * requested.
  524        * @throws BuildException if a reference does not have a refid.
  525        */
  526       private void addReferences() throws BuildException {
  527           Hashtable thisReferences
  528               = (Hashtable) getProject().getReferences().clone();
  529           Hashtable newReferences = newProject.getReferences();
  530           Enumeration e;
  531           if (references.size() > 0) {
  532               for (e = references.elements(); e.hasMoreElements();) {
  533                   Reference ref = (Reference) e.nextElement();
  534                   String refid = ref.getRefId();
  535                   if (refid == null) {
  536                       throw new BuildException("the refid attribute is required"
  537                                                + " for reference elements");
  538                   }
  539                   if (!thisReferences.containsKey(refid)) {
  540                       log("Parent project doesn't contain any reference '"
  541                           + refid + "'",
  542                           Project.MSG_WARN);
  543                       continue;
  544                   }
  545   
  546                   thisReferences.remove(refid);
  547                   String toRefid = ref.getToRefid();
  548                   if (toRefid == null) {
  549                       toRefid = refid;
  550                   }
  551                   copyReference(refid, toRefid);
  552               }
  553           }
  554   
  555           // Now add all references that are not defined in the
  556           // subproject, if inheritRefs is true
  557           if (inheritRefs) {
  558               for (e = thisReferences.keys(); e.hasMoreElements();) {
  559                   String key = (String) e.nextElement();
  560                   if (newReferences.containsKey(key)) {
  561                       continue;
  562                   }
  563                   copyReference(key, key);
  564                   newProject.inheritIDReferences(getProject());
  565               }
  566           }
  567       }
  568   
  569       /**
  570        * Try to clone and reconfigure the object referenced by oldkey in
  571        * the parent project and add it to the new project with the key newkey.
  572        *
  573        * <p>If we cannot clone it, copy the referenced object itself and
  574        * keep our fingers crossed.</p>
  575        * @param oldKey the reference id in the current project.
  576        * @param newKey the reference id in the new project.
  577        */
  578       private void copyReference(String oldKey, String newKey) {
  579           Object orig = getProject().getReference(oldKey);
  580           if (orig == null) {
  581               log("No object referenced by " + oldKey + ". Can't copy to "
  582                   + newKey,
  583                   Project.MSG_WARN);
  584               return;
  585           }
  586   
  587           Class c = orig.getClass();
  588           Object copy = orig;
  589           try {
  590               Method cloneM = c.getMethod("clone", new Class[0]);
  591               if (cloneM != null) {
  592                   copy = cloneM.invoke(orig, new Object[0]);
  593                   log("Adding clone of reference " + oldKey, Project.MSG_DEBUG);
  594               }
  595           } catch (Exception e) {
  596               // not Clonable
  597           }
  598   
  599   
  600           if (copy instanceof ProjectComponent) {
  601               ((ProjectComponent) copy).setProject(newProject);
  602           } else {
  603               try {
  604                   Method setProjectM =
  605                       c.getMethod("setProject", new Class[] {Project.class});
  606                   if (setProjectM != null) {
  607                       setProjectM.invoke(copy, new Object[] {newProject});
  608                   }
  609               } catch (NoSuchMethodException e) {
  610                   // ignore this if the class being referenced does not have
  611                   // a set project method.
  612               } catch (Exception e2) {
  613                   String msg = "Error setting new project instance for "
  614                       + "reference with id " + oldKey;
  615                   throw new BuildException(msg, e2, getLocation());
  616               }
  617           }
  618           newProject.addReference(newKey, copy);
  619       }
  620   
  621       /**
  622        * Copies all properties from the given table to the new project -
  623        * omitting those that have already been set in the new project as
  624        * well as properties named basedir or ant.file.
  625        * @param props properties <code>Hashtable</code> to copy to the
  626        * new project.
  627        * @param the type of property to set (a plain Ant property, a
  628        * user property or an inherited property).
  629        * @since Ant 1.8.0
  630        */
  631       private void addAlmostAll(Hashtable props, PropertyType type) {
  632           Enumeration e = props.keys();
  633           while (e.hasMoreElements()) {
  634               String key = e.nextElement().toString();
  635               if (MagicNames.PROJECT_BASEDIR.equals(key)
  636                   || MagicNames.ANT_FILE.equals(key)) {
  637                   // basedir and ant.file get special treatment in execute()
  638                   continue;
  639               }
  640   
  641               String value = props.get(key).toString();
  642               if (type == PropertyType.PLAIN) {
  643                   // don't re-set user properties, avoid the warning message
  644                   if (newProject.getProperty(key) == null) {
  645                       // no user property
  646                       newProject.setNewProperty(key, value);
  647                   }
  648               } else if (type == PropertyType.USER) {
  649                   newProject.setUserProperty(key, value);
  650               } else if (type == PropertyType.INHERITED) {
  651                   newProject.setInheritedProperty(key, value);
  652               }
  653           }
  654       }
  655   
  656       /**
  657        * The directory to use as a base directory for the new Ant project.
  658        * Defaults to the current project's basedir, unless inheritall
  659        * has been set to false, in which case it doesn't have a default
  660        * value. This will override the basedir setting of the called project.
  661        * @param dir new directory as <code>File</code>.
  662        */
  663       public void setDir(File dir) {
  664           this.dir = dir;
  665       }
  666   
  667       /**
  668        * The build file to use. Defaults to "build.xml". This file is expected
  669        * to be a filename relative to the dir attribute given.
  670        * @param antFile the <code>String</code> build file name.
  671        */
  672       public void setAntfile(String antFile) {
  673           // @note: it is a string and not a file to handle relative/absolute
  674           // otherwise a relative file will be resolved based on the current
  675           // basedir.
  676           this.antFile = antFile;
  677       }
  678   
  679       /**
  680        * The target of the new Ant project to execute.
  681        * Defaults to the new project's default target.
  682        * @param targetToAdd the name of the target to invoke.
  683        */
  684       public void setTarget(String targetToAdd) {
  685           if (targetToAdd.equals("")) {
  686               throw new BuildException("target attribute must not be empty");
  687           }
  688           targets.add(targetToAdd);
  689           targetAttributeSet = true;
  690       }
  691   
  692       /**
  693        * Set the filename to write the output to. This is relative to the value
  694        * of the dir attribute if it has been set or to the base directory of the
  695        * current project otherwise.
  696        * @param outputFile the name of the file to which the output should go.
  697        */
  698       public void setOutput(String outputFile) {
  699           this.output = outputFile;
  700       }
  701   
  702       /**
  703        * Property to pass to the new project.
  704        * The property is passed as a 'user property'.
  705        * @return the created <code>Property</code> object.
  706        */
  707       public Property createProperty() {
  708           Property p = new Property(true, getProject());
  709           p.setProject(getNewProject());
  710           p.setTaskName("property");
  711           properties.addElement(p);
  712           return p;
  713       }
  714   
  715       /**
  716        * Add a Reference element identifying a data type to carry
  717        * over to the new project.
  718        * @param ref <code>Reference</code> to add.
  719        */
  720       public void addReference(Reference ref) {
  721           references.addElement(ref);
  722       }
  723   
  724       /**
  725        * Add a target to this Ant invocation.
  726        * @param t the <code>TargetElement</code> to add.
  727        * @since Ant 1.6.3
  728        */
  729       public void addConfiguredTarget(TargetElement t) {
  730           if (targetAttributeSet) {
  731               throw new BuildException(
  732                   "nested target is incompatible with the target attribute");
  733           }
  734           String name = t.getName();
  735           if (name.equals("")) {
  736               throw new BuildException("target name must not be empty");
  737           }
  738           targets.add(name);
  739       }
  740   
  741       /**
  742        * Add a set of properties to pass to the new project.
  743        *
  744        * @param ps <code>PropertySet</code> to add.
  745        * @since Ant 1.6
  746        */
  747       public void addPropertyset(PropertySet ps) {
  748           propertySets.addElement(ps);
  749       }
  750   
  751       /**
  752        * Get the (sub)-Project instance currently in use.
  753        * @return Project
  754        * @since Ant 1.7
  755        */
  756       protected Project getNewProject() {
  757           if (newProject == null) {
  758               reinit();
  759           }
  760           return newProject;
  761       }
  762   
  763       /**
  764        * @since Ant 1.6.2
  765        */
  766       private Iterator getBuildListeners() {
  767           return getProject().getBuildListeners().iterator();
  768       }
  769   
  770       /**
  771        * Helper class that implements the nested &lt;reference&gt;
  772        * element of &lt;ant&gt; and &lt;antcall&gt;.
  773        */
  774       public static class Reference
  775           extends org.apache.tools.ant.types.Reference {
  776   
  777           /** Creates a reference to be configured by Ant. */
  778           public Reference() {
  779                   super();
  780           }
  781   
  782           private String targetid = null;
  783   
  784           /**
  785            * Set the id that this reference to be stored under in the
  786            * new project.
  787            *
  788            * @param targetid the id under which this reference will be passed to
  789            *        the new project. */
  790           public void setToRefid(String targetid) {
  791               this.targetid = targetid;
  792           }
  793   
  794           /**
  795            * Get the id under which this reference will be stored in the new
  796            * project.
  797            *
  798            * @return the id of the reference in the new project.
  799            */
  800           public String getToRefid() {
  801               return targetid;
  802           }
  803       }
  804   
  805       /**
  806        * Helper class that implements the nested &lt;target&gt;
  807        * element of &lt;ant&gt; and &lt;antcall&gt;.
  808        * @since Ant 1.6.3
  809        */
  810       public static class TargetElement {
  811           private String name;
  812   
  813           /**
  814            * Default constructor.
  815            */
  816           public TargetElement() {
  817                   //default
  818           }
  819   
  820           /**
  821            * Set the name of this TargetElement.
  822            * @param name   the <code>String</code> target name.
  823            */
  824           public void setName(String name) {
  825               this.name = name;
  826           }
  827   
  828           /**
  829            * Get the name of this TargetElement.
  830            * @return <code>String</code>.
  831            */
  832           public String getName() {
  833               return name;
  834           }
  835       }
  836   
  837       private static final class PropertyType {
  838           private PropertyType() {}
  839           private static final PropertyType PLAIN = new PropertyType();
  840           private static final PropertyType INHERITED = new PropertyType();
  841           private static final PropertyType USER = new PropertyType();
  842       }
  843   }

Save This Page
Home » apache-ant-1.8.1 » org.apache.tools » ant » taskdefs » [javadoc | source]