FileDocCategorySizeDatePackage
RedirectorElement.javaAPI DocApache Ant 1.7019450Wed Dec 13 06:16:22 GMT 2006org.apache.tools.ant.types

RedirectorElement

public class RedirectorElement extends DataType
Element representation of a Redirector.
since
Ant 1.6.2

Fields Summary
private boolean
usingInput
Whether the input mapper was set via setOutput.
private boolean
usingOutput
Whether the output mapper was set via setOutput.
private boolean
usingError
Whether the error mapper was set via setError.
private Boolean
logError
Indicates if standard error should be logged to Ant's log system rather than the output. This has no effect if standard error is redirected to a file or property.
private String
outputProperty
The name of the property into which output is to be stored
private String
errorProperty
The name of the property into which error output is to be stored
private String
inputString
String from which input is taken
private Boolean
append
Flag which indicates if error and output files are to be appended.
private Boolean
alwaysLog
Flag which indicates that output should be always sent to the log
private Boolean
createEmptyFiles
Flag which indicates whether files should be created even if empty.
private Mapper
inputMapper
Input file mapper.
private Mapper
outputMapper
Output file mapper.
private Mapper
errorMapper
Error file mapper.
private Vector
inputFilterChains
input filter chains.
private Vector
outputFilterChains
output filter chains.
private Vector
errorFilterChains
error filter chains.
private String
outputEncoding
The output encoding
private String
errorEncoding
The error encoding
private String
inputEncoding
The input encoding
private Boolean
logInputString
whether to log the inputstring
Constructors Summary
Methods Summary
public voidaddConfiguredErrorMapper(Mapper errorMapper)
Add the error file mapper.

param
errorMapper Mapper.

        if (isReference()) {
            throw noChildrenAllowed();
        }
        if (this.errorMapper != null) {
            if (usingError) {
                throw new BuildException("attribute \"error\""
                    + " cannot coexist with a nested <errormapper>");
            } else {
                throw new BuildException("Cannot have > 1 <errormapper>");
            }
        }
        this.errorMapper = errorMapper;
public voidaddConfiguredInputMapper(Mapper inputMapper)
Add the input file mapper.

param
inputMapper Mapper.


                   
        
        if (isReference()) {
            throw noChildrenAllowed();
        }
        if (this.inputMapper != null) {
            if (usingInput) {
                throw new BuildException("attribute \"input\""
                    + " cannot coexist with a nested <inputmapper>");
            } else {
                throw new BuildException("Cannot have > 1 <inputmapper>");
            }
        }
        this.inputMapper = inputMapper;
public voidaddConfiguredOutputMapper(Mapper outputMapper)
Add the output file mapper.

param
outputMapper Mapper.

        if (isReference()) {
            throw noChildrenAllowed();
        }
        if (this.outputMapper != null) {
            if (usingOutput) {
                throw new BuildException("attribute \"output\""
                    + " cannot coexist with a nested <outputmapper>");
            } else {
                throw new BuildException("Cannot have > 1 <outputmapper>");
            }
        }
        this.outputMapper = outputMapper;
public voidconfigure(org.apache.tools.ant.taskdefs.Redirector redirector)
Configure the specified Redirector.

param
redirector Redirector.

        configure(redirector, null);
public voidconfigure(org.apache.tools.ant.taskdefs.Redirector redirector, java.lang.String sourcefile)
Configure the specified Redirector for the specified sourcefile.

param
redirector Redirector.
param
sourcefile String.

        if (isReference()) {
            getRef().configure(redirector, sourcefile);
            return;
        }
        if (alwaysLog != null) {
            redirector.setAlwaysLog(alwaysLog.booleanValue());
        }
        if (logError != null) {
            redirector.setLogError(logError.booleanValue());
        }
        if (append != null) {
            redirector.setAppend(append.booleanValue());
        }
        if (createEmptyFiles != null) {
            redirector.setCreateEmptyFiles(createEmptyFiles.booleanValue());
        }
        if (outputProperty != null) {
            redirector.setOutputProperty(outputProperty);
        }
        if (errorProperty != null) {
            redirector.setErrorProperty(errorProperty);
        }
        if (inputString != null) {
            redirector.setInputString(inputString);
        }
        if (logInputString != null) {
            redirector.setLogInputString(logInputString.booleanValue());
        }
        if (inputMapper != null) {
            String[] inputTargets = null;
            try {
                inputTargets =
                    inputMapper.getImplementation().mapFileName(sourcefile);
            } catch (NullPointerException enPeaEx) {
                if (sourcefile != null) {
                    throw enPeaEx;
                }
            }
            if (inputTargets != null && inputTargets.length > 0) {
                redirector.setInput(toFileArray(inputTargets));
            }
        }
        if (outputMapper != null) {
            String[] outputTargets = null;
            try {
                outputTargets =
                    outputMapper.getImplementation().mapFileName(sourcefile);
            } catch (NullPointerException enPeaEx) {
                if (sourcefile != null) {
                    throw enPeaEx;
                }
            }
            if (outputTargets != null && outputTargets.length > 0) {
                redirector.setOutput(toFileArray(outputTargets));
            }
        }
        if (errorMapper != null) {
            String[] errorTargets = null;
            try {
                errorTargets =
                    errorMapper.getImplementation().mapFileName(sourcefile);
            } catch (NullPointerException enPeaEx) {
                if (sourcefile != null) {
                    throw enPeaEx;
                }
            }
            if (errorTargets != null && errorTargets.length > 0) {
                redirector.setError(toFileArray(errorTargets));
            }
        }
        if (inputFilterChains.size() > 0) {
            redirector.setInputFilterChains(inputFilterChains);
        }
        if (outputFilterChains.size() > 0) {
            redirector.setOutputFilterChains(outputFilterChains);
        }
        if (errorFilterChains.size() > 0) {
            redirector.setErrorFilterChains(errorFilterChains);
        }
        if (inputEncoding != null) {
            redirector.setInputEncoding(inputEncoding);
        }
        if (outputEncoding != null) {
            redirector.setOutputEncoding(outputEncoding);
        }
        if (errorEncoding != null) {
            redirector.setErrorEncoding(errorEncoding);
        }
public FilterChaincreateErrorFilterChain()
Create a nested error FilterChain.

return
FilterChain.

        if (isReference()) {
            throw noChildrenAllowed();
        }
        FilterChain result = new FilterChain();
        result.setProject(getProject());
        errorFilterChains.add(result);
        return result;
public FilterChaincreateInputFilterChain()
Create a nested input FilterChain.

return
FilterChain.

        if (isReference()) {
            throw noChildrenAllowed();
        }
        FilterChain result = new FilterChain();
        result.setProject(getProject());
        inputFilterChains.add(result);
        return result;
protected MappercreateMergeMapper(java.io.File destfile)
Create a merge mapper pointing to the specified destination file.

param
destfile File
return
Mapper.

        Mapper result = new Mapper(getProject());
        result.setClassname(
            org.apache.tools.ant.util.MergingMapper.class.getName());
        result.setTo(destfile.getAbsolutePath());
        return result;
public FilterChaincreateOutputFilterChain()
Create a nested output FilterChain.

return
FilterChain.

        if (isReference()) {
            throw noChildrenAllowed();
        }
        FilterChain result = new FilterChain();
        result.setProject(getProject());
        outputFilterChains.add(result);
        return result;
protected voiddieOnCircularReference(java.util.Stack stk, org.apache.tools.ant.Project p)
Overrides the version of DataType to recurse on all DataType child elements that may have been added.

param
stk the stack of data types to use (recursively).
param
p the project to use to dereference the references.
throws
BuildException on error.

        if (isChecked()) {
            return;
        }
        if (isReference()) {
            super.dieOnCircularReference(stk, p);
        } else {
            Mapper[] m = new Mapper[] {inputMapper, outputMapper, errorMapper};
            for (int i = 0; i < m.length; i++) {
                if (m[i] != null) {
                    stk.push(m[i]);
                    m[i].dieOnCircularReference(stk, p);
                    stk.pop();
                }
            }
            Vector[] v = new Vector[]
                {inputFilterChains, outputFilterChains, errorFilterChains};
            for (int i = 0; i < v.length; i++) {
                if (v[i] != null) {
                    for (Iterator fci = v[i].iterator(); fci.hasNext();) {
                        FilterChain fc = (FilterChain) fci.next();
                        stk.push(fc);
                        fc.dieOnCircularReference(stk, p);
                        stk.pop();
                    }
                }
            }
            setChecked(true);
        }
private org.apache.tools.ant.types.RedirectorElementgetRef()
Perform the check for circular references, returning the referenced RedirectorElement.

return
the referenced RedirectorElement.

        return (RedirectorElement) getCheckedRef();
public voidsetAlwaysLog(boolean alwaysLog)
If true, (error and non-error) output will be "teed", redirected as specified while being sent to Ant's logging mechanism as if no redirection had taken place. Defaults to false.

param
alwaysLog boolean
since
Ant 1.6.3

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.alwaysLog = ((alwaysLog) ? Boolean.TRUE : Boolean.FALSE);
public voidsetAppend(boolean append)
Whether output should be appended to or overwrite an existing file. Defaults to false.

param
append if true output and error streams are appended to their respective files, if specified.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.append = ((append) ? Boolean.TRUE : Boolean.FALSE);
public voidsetCreateEmptyFiles(boolean createEmptyFiles)
Whether output and error files should be created even when empty. Defaults to true.

param
createEmptyFiles boolean.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.createEmptyFiles = ((createEmptyFiles)
            ? Boolean.TRUE : Boolean.FALSE);
public voidsetError(java.io.File error)
Set the file to which standard error is to be redirected.

param
error the file to which error is to be written.

        if (isReference()) {
            throw tooManyAttributes();
        }
        if (error == null) {
            throw new IllegalArgumentException("error file specified as null");
        }
        usingError = true;
        errorMapper = createMergeMapper(error);
public voidsetErrorEncoding(java.lang.String errorEncoding)
Set the error encoding.

param
errorEncoding String.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.errorEncoding = errorEncoding;
public voidsetErrorProperty(java.lang.String errorProperty)
Property name whose value should be set to the error of the process.

param
errorProperty the name of the property to be set with the error output.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.errorProperty = errorProperty;
public voidsetInput(java.io.File input)
Set the input to use for the task.

param
input the file from which input is read.

        if (isReference()) {
            throw tooManyAttributes();
        }
        if (inputString != null) {
            throw new BuildException("The \"input\" and \"inputstring\" "
                + "attributes cannot both be specified");
        }
        usingInput = true;
        inputMapper = createMergeMapper(input);
public voidsetInputEncoding(java.lang.String inputEncoding)
Set the input encoding.

param
inputEncoding String.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.inputEncoding = inputEncoding;
public voidsetInputString(java.lang.String inputString)
Set the string to use as input

param
inputString the string which is used as the input source

        if (isReference()) {
            throw tooManyAttributes();
        }
        if (usingInput) {
            throw new BuildException("The \"input\" and \"inputstring\" "
                + "attributes cannot both be specified");
        }
        this.inputString = inputString;
public voidsetLogError(boolean logError)
Controls whether error output of exec is logged. This is only useful when output is being redirected and error output is desired in the Ant log.

param
logError if true the standard error is sent to the Ant log system and not sent to output.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.logError = ((logError) ? Boolean.TRUE : Boolean.FALSE);
public voidsetLogInputString(boolean logInputString)
Set whether to include the value of the input string in log messages. Defaults to true.

param
logInputString true or false.
since
Ant 1.7

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.logInputString = logInputString ? Boolean.TRUE : Boolean.FALSE;
public voidsetOutput(java.io.File out)
File the output of the process is redirected to. If error is not redirected, it too will appear in the output.

param
out the file to which output stream is written.

        if (isReference()) {
            throw tooManyAttributes();
        }
        if (out == null) {
            throw new IllegalArgumentException("output file specified as null");
        }
        usingOutput = true;
        outputMapper = createMergeMapper(out);
public voidsetOutputEncoding(java.lang.String outputEncoding)
Set the output encoding.

param
outputEncoding String.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.outputEncoding = outputEncoding;
public voidsetOutputProperty(java.lang.String outputProperty)
Property name whose value should be set to the output of the process.

param
outputProperty the name of the property to be set with the task's output.

        if (isReference()) {
            throw tooManyAttributes();
        }
        this.outputProperty = outputProperty;
public voidsetRefid(Reference r)
Make this instance in effect a reference to another instance.

You must not set another attribute or nest elements inside this element if you make it a reference.

param
r the reference to use.
throws
BuildException on error.

        if (usingInput
            || usingOutput
            || usingError
            || inputString != null
            || logError != null
            || append != null
            || createEmptyFiles != null
            || inputEncoding != null
            || outputEncoding != null
            || errorEncoding != null
            || outputProperty != null
            || errorProperty != null
            || logInputString != null) {
            throw tooManyAttributes();
        }
        super.setRefid(r);
protected java.io.File[]toFileArray(java.lang.String[] name)
Return a File[] from the specified set of filenames.

param
name String[]
return
File[].

        if (name == null) {
            return null;
        }
        //remove any null elements
        ArrayList list = new ArrayList(name.length);
        for (int i = 0; i < name.length; i++) {
            if (name[i] != null) {
                list.add(getProject().resolveFile(name[i]));
            }
        }
        return (File[]) (list.toArray(new File[list.size()]));