| Methods Summary |
|---|
| private void | addAlmostAll(java.util.Hashtable props)Copies all properties from the given table to the new project -
omitting those that have already been set in the new project as
well as properties named basedir or ant.file.
Enumeration e = props.keys();
while (e.hasMoreElements()) {
String key = e.nextElement().toString();
if (MagicNames.PROJECT_BASEDIR.equals(key) || MagicNames.ANT_FILE.equals(key)) {
// basedir and ant.file get special treatment in execute()
continue;
}
String value = props.get(key).toString();
// don't re-set user properties, avoid the warning message
if (newProject.getProperty(key) == null) {
// no user property
newProject.setNewProperty(key, value);
}
}
|
| public void | addConfiguredTarget(org.apache.tools.ant.taskdefs.Ant$TargetElement t)Add a target to this Ant invocation.
if (targetAttributeSet) {
throw new BuildException(
"nested target is incompatible with the target attribute");
}
String name = t.getName();
if (name.equals("")) {
throw new BuildException("target name must not be empty");
}
targets.add(name);
|
| public void | addPropertyset(org.apache.tools.ant.types.PropertySet ps)Add a set of properties to pass to the new project.
propertySets.addElement(ps);
|
| public void | addReference(org.apache.tools.ant.taskdefs.Ant$Reference ref)Add a Reference element identifying a data type to carry
over to the new project.
references.addElement(ref);
|
| private void | addReferences()Add the references explicitly defined as nested elements to the
new project. Also copy over all references that don't override
existing references in the new project if inheritrefs has been
requested.
Hashtable thisReferences
= (Hashtable) getProject().getReferences().clone();
Hashtable newReferences = newProject.getReferences();
Enumeration e;
if (references.size() > 0) {
for (e = references.elements(); e.hasMoreElements();) {
Reference ref = (Reference) e.nextElement();
String refid = ref.getRefId();
if (refid == null) {
throw new BuildException("the refid attribute is required"
+ " for reference elements");
}
if (!thisReferences.containsKey(refid)) {
log("Parent project doesn't contain any reference '"
+ refid + "'",
Project.MSG_WARN);
continue;
}
thisReferences.remove(refid);
String toRefid = ref.getToRefid();
if (toRefid == null) {
toRefid = refid;
}
copyReference(refid, toRefid);
}
}
// Now add all references that are not defined in the
// subproject, if inheritRefs is true
if (inheritRefs) {
for (e = thisReferences.keys(); e.hasMoreElements();) {
String key = (String) e.nextElement();
if (newReferences.containsKey(key)) {
continue;
}
copyReference(key, key);
newProject.inheritIDReferences(getProject());
}
}
|
| private void | copyReference(java.lang.String oldKey, java.lang.String newKey)Try to clone and reconfigure the object referenced by oldkey in
the parent project and add it to the new project with the key newkey.
If we cannot clone it, copy the referenced object itself and
keep our fingers crossed.
Object orig = getProject().getReference(oldKey);
if (orig == null) {
log("No object referenced by " + oldKey + ". Can't copy to "
+ newKey,
Project.MSG_WARN);
return;
}
Class c = orig.getClass();
Object copy = orig;
try {
Method cloneM = c.getMethod("clone", new Class[0]);
if (cloneM != null) {
copy = cloneM.invoke(orig, new Object[0]);
log("Adding clone of reference " + oldKey, Project.MSG_DEBUG);
}
} catch (Exception e) {
// not Clonable
}
if (copy instanceof ProjectComponent) {
((ProjectComponent) copy).setProject(newProject);
} else {
try {
Method setProjectM =
c.getMethod("setProject", new Class[] {Project.class});
if (setProjectM != null) {
setProjectM.invoke(copy, new Object[] {newProject});
}
} catch (NoSuchMethodException e) {
// ignore this if the class being referenced does not have
// a set project method.
} catch (Exception e2) {
String msg = "Error setting new project instance for "
+ "reference with id " + oldKey;
throw new BuildException(msg, e2, getLocation());
}
}
newProject.addReference(newKey, copy);
|
| public Property | createProperty()Property to pass to the new project.
The property is passed as a 'user property'.
Property p = new Property(true, getProject());
p.setProject(getNewProject());
p.setTaskName("property");
properties.addElement(p);
return p;
|
| public void | execute()Do the execution.
File savedDir = dir;
String savedAntFile = antFile;
Vector locals = new Vector(targets);
try {
getNewProject();
if (dir == null && inheritAll) {
dir = getProject().getBaseDir();
}
initializeProject();
if (dir != null) {
newProject.setBaseDir(dir);
if (savedDir != null) {
// has been set explicitly
newProject.setInheritedProperty(MagicNames.PROJECT_BASEDIR,
dir.getAbsolutePath());
}
} else {
dir = getProject().getBaseDir();
}
overrideProperties();
if (antFile == null) {
antFile = Main.DEFAULT_BUILD_FILENAME;
}
File file = FILE_UTILS.resolveFile(dir, antFile);
antFile = file.getAbsolutePath();
log("calling target(s) "
+ ((locals.size() > 0) ? locals.toString() : "[default]")
+ " in build file " + antFile, Project.MSG_VERBOSE);
newProject.setUserProperty(MagicNames.ANT_FILE , antFile);
String thisAntFile = getProject().getProperty(MagicNames.ANT_FILE);
// Are we trying to call the target in which we are defined (or
// the build file if this is a top level task)?
if (thisAntFile != null
&& file.equals(getProject().resolveFile(thisAntFile))
&& getOwningTarget() != null) {
if (getOwningTarget().getName().equals("")) {
if (getTaskName().equals("antcall")) {
throw new BuildException("antcall must not be used at"
+ " the top level.");
}
throw new BuildException(getTaskName() + " task at the"
+ " top level must not invoke"
+ " its own build file.");
}
}
try {
ProjectHelper.configureProject(newProject, file);
} catch (BuildException ex) {
throw ProjectHelper.addLocationToBuildException(
ex, getLocation());
}
if (locals.size() == 0) {
String defaultTarget = newProject.getDefaultTarget();
if (defaultTarget != null) {
locals.add(defaultTarget);
}
}
if (newProject.getProperty(MagicNames.ANT_FILE)
.equals(getProject().getProperty(MagicNames.ANT_FILE))
&& getOwningTarget() != null) {
String owningTargetName = getOwningTarget().getName();
if (locals.contains(owningTargetName)) {
throw new BuildException(getTaskName() + " task calling "
+ "its own parent target.");
}
boolean circular = false;
for (Iterator it = locals.iterator();
!circular && it.hasNext();) {
Target other =
(Target) (getProject().getTargets().get(it.next()));
circular |= (other != null
&& other.dependsOn(owningTargetName));
}
if (circular) {
throw new BuildException(getTaskName()
+ " task calling a target"
+ " that depends on"
+ " its parent target \'"
+ owningTargetName
+ "\'.");
}
}
addReferences();
if (locals.size() > 0 && !(locals.size() == 1
&& "".equals(locals.get(0)))) {
BuildException be = null;
try {
log("Entering " + antFile + "...", Project.MSG_VERBOSE);
newProject.fireSubBuildStarted();
newProject.executeTargets(locals);
} catch (BuildException ex) {
be = ProjectHelper
.addLocationToBuildException(ex, getLocation());
throw be;
} finally {
log("Exiting " + antFile + ".", Project.MSG_VERBOSE);
newProject.fireSubBuildFinished(be);
}
}
} finally {
// help the gc
newProject = null;
Enumeration e = properties.elements();
while (e.hasMoreElements()) {
Property p = (Property) e.nextElement();
p.setProject(null);
}
if (output != null && out != null) {
try {
out.close();
} catch (final Exception ex) {
//ignore
}
}
dir = savedDir;
antFile = savedAntFile;
}
|
| private java.util.Iterator | getBuildListeners()
return getProject().getBuildListeners().iterator();
|
| protected org.apache.tools.ant.Project | getNewProject()
if (newProject == null) {
reinit();
}
return newProject;
|
| public void | handleErrorFlush(java.lang.String errorOutputToFlush)Handle error output.
Send it the the new project if is present, otherwise
call the super class.
if (newProject != null) {
newProject.demuxFlush(errorOutputToFlush, true);
} else {
super.handleErrorFlush(errorOutputToFlush);
}
|
| public void | handleErrorOutput(java.lang.String errorOutputToHandle)Handle error output.
Send it the the new project if is present, otherwise
call the super class.
if (newProject != null) {
newProject.demuxOutput(errorOutputToHandle, true);
} else {
super.handleErrorOutput(errorOutputToHandle);
}
|
| public void | handleFlush(java.lang.String toFlush)Handles output.
Send it the the new project if is present, otherwise
call the super class.
if (newProject != null) {
newProject.demuxFlush(toFlush, false);
} else {
super.handleFlush(toFlush);
}
|
| public int | handleInput(byte[] buffer, int offset, int length)Handles input.
Deleate to the created project, if present, otherwise
call the super class.
if (newProject != null) {
return newProject.demuxInput(buffer, offset, length);
}
return super.handleInput(buffer, offset, length);
|
| public void | handleOutput(java.lang.String outputToHandle)Handles output.
Send it the the new project if is present, otherwise
call the super class.
if (newProject != null) {
newProject.demuxOutput(outputToHandle, false);
} else {
super.handleOutput(outputToHandle);
}
|
| public void | init()Creates a Project instance for the project to call.
newProject = getProject().createSubProject();
newProject.setJavaVersionProperty();
|
| private void | initializeProject()Attaches the build listeners of the current project to the new
project, configures a possible logfile, transfers task and
data-type definitions, transfers properties (either all or just
the ones specified as user properties to the current project,
depending on inheritall), transfers the input handler.
newProject.setInputHandler(getProject().getInputHandler());
Iterator iter = getBuildListeners();
while (iter.hasNext()) {
newProject.addBuildListener((BuildListener) iter.next());
}
if (output != null) {
File outfile = null;
if (dir != null) {
outfile = FILE_UTILS.resolveFile(dir, output);
} else {
outfile = getProject().resolveFile(output);
}
try {
out = new PrintStream(new FileOutputStream(outfile));
DefaultLogger logger = new DefaultLogger();
logger.setMessageOutputLevel(Project.MSG_INFO);
logger.setOutputPrintStream(out);
logger.setErrorPrintStream(out);
newProject.addBuildListener(logger);
} catch (IOException ex) {
log("Ant: Can't set output to " + output);
}
}
// set user-defined properties
getProject().copyUserProperties(newProject);
if (!inheritAll) {
// set Java built-in properties separately,
// b/c we won't inherit them.
newProject.setSystemProperties();
} else {
// set all properties from calling project
addAlmostAll(getProject().getProperties());
}
Enumeration e = propertySets.elements();
while (e.hasMoreElements()) {
PropertySet ps = (PropertySet) e.nextElement();
addAlmostAll(ps.getProperties());
}
|
| private void | overrideProperties()Override the properties in the new project with the one
explicitly defined as nested elements here.
// remove duplicate properties - last property wins
// Needed for backward compatibility
Set set = new HashSet();
for (int i = properties.size() - 1; i >= 0; --i) {
Property p = (Property) properties.get(i);
if (p.getName() != null && !p.getName().equals("")) {
if (set.contains(p.getName())) {
properties.remove(i);
} else {
set.add(p.getName());
}
}
}
Enumeration e = properties.elements();
while (e.hasMoreElements()) {
Property p = (Property) e.nextElement();
p.setProject(newProject);
p.execute();
}
getProject().copyInheritedProperties(newProject);
|
| private void | reinit()Called in execute or createProperty (via getNewProject())
if newProject is null.
This can happen if the same instance of this task is run
twice as newProject is set to null at the end of execute (to
save memory and help the GC).
calls init() again
init();
|
| public void | setAntfile(java.lang.String antFile)The build file to use. Defaults to "build.xml". This file is expected
to be a filename relative to the dir attribute given.
// @note: it is a string and not a file to handle relative/absolute
// otherwise a relative file will be resolved based on the current
// basedir.
this.antFile = antFile;
|
| public void | setDir(java.io.File dir)The directory to use as a base directory for the new Ant project.
Defaults to the current project's basedir, unless inheritall
has been set to false, in which case it doesn't have a default
value. This will override the basedir setting of the called project.
this.dir = dir;
|
| public void | setInheritAll(boolean value)If true, pass all properties to the new Ant project.
Defaults to true.
inheritAll = value;
|
| public void | setInheritRefs(boolean value)If true, pass all references to the new Ant project.
Defaults to false.
inheritRefs = value;
|
| public void | setOutput(java.lang.String outputFile)Set the filename to write the output to. This is relative to the value
of the dir attribute if it has been set or to the base directory of the
current project otherwise.
this.output = outputFile;
|
| public void | setTarget(java.lang.String targetToAdd)The target of the new Ant project to execute.
Defaults to the new project's default target.
if (targetToAdd.equals("")) {
throw new BuildException("target attribute must not be empty");
}
targets.add(targetToAdd);
targetAttributeSet = true;
|
