# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary
AbstractAccessTask
AbstractAnalyzer: An abstract implementation of the analyzer interface providing support for the bulk of interface methods.
AbstractClasspathResource: A Resource representation of anything that is accessed via a Java classloader.
AbstractClasspathResource.ClassLoaderWithFlag
AbstractCvsTask: original Cvs.java 1.20
AbstractCvsTask.Module
AbstractFileSet: Class that holds an implicit patternset and supports nested patternsets and creates a DirectoryScanner using these patterns.
AbstractHotDeploymentTool: Abstract class to support vendor-specific hot deployment tools.
AbstractJarSignerTask: This is factored out from `SignJar`; a base class that can be used for both signing and verifying JAR files using jarsigner
AbstractResourceCollectionWrapper: Base class for a ResourceCollection that wraps a single nested ResourceCollection.
AbstractScriptComponent: This is a `ProjectComponent` that has script support built in Use it as a foundation for scriptable things.
AbstractSelectorContainer: This is the a base class a container of selectors - it does not need do be a selector itself.
AbstractSshMessage: Abstract class for ssh upload and download
AbstractUnicodeExtraField: A common base class for Unicode extra information extra fields.
AggregateTransformer: Transform a JUnit xml report.
AggregateTransformer.Format: defines acceptable formats.
Algorithm: The Algorithm defines how a value for a file is computed.
AllButFirst: ResourceCollection that contains all resources of another collection except for the first `count` elements, a la the UNIX tail command with parameter `-n +count`.
AllButLast: ResourceCollection that contains all resources of another collection except for the last `count` elements, a la the UNIX head command with parameter `-n -count`.
AncestorAnalyzer: A dependency analyzer which returns superclass and superinterface dependencies.
And: <and> condition container.
And: And ResourceSelector.
AndSelector: This selector has a collection of other selectors, all of which have to select a file in order for this selector to select it.
AnsiColorLogger: Uses ANSI Color Code Sequences to colorize messages sent to the console.
Ant: Build a sub-project.
Ant.Reference: Helper class that implements the nested <reference> element of <ant> and <antcall>.
Ant.TargetElement: Helper class that implements the nested <target> element of <ant> and <antcall>.
AntAnalyzer: An analyzer which uses the depend task's bytecode classes to analyze dependencies
AntClassLoader: Used to load classes within ant with a different classpath from that used to start ant.
AntClassLoader2: Deprecated. since 1.7 Just use `AntClassLoader` itself.
AntClassLoader5: Deprecated. since 1.9.7 Just use `AntClassLoader` itself.
AntFilterReader: An AntFilterReader is a wrapper class that encloses the classname and configuration of a Configurable FilterReader.
Antlib: Antlib task.
AntlibDefinition: Base class for tasks that that can be used in antlibs.
ANTLR: Invokes the ANTLR Translator generator on a grammar file.
AntMain: Interface used to bridge to the actual Main class without any messy reflection
AntResolver: Resolver that just returns s specified location.
AntSoundPlayer: This class is designed to be used by any AntTask that requires audio output.
AntStructure: Creates a partial DTD for Ant from the currently known tasks.
AntStructure.StructurePrinter: Writes the actual structure information.
AntTypeDefinition: This class contains all the information on a particular ant type, the classname, adapter and the class it should be assignable from.
AntVersion: An Ant version condition.
AntXMLContext: Context information for the ant processing.
ApacheCatalog: This class extends the Catalog class provided by Norman Walsh's resolver library in xml-commons in order to add classpath entity and URI resolution.
ApacheCatalogResolver: This class extends the CatalogResolver class provided by Norman Walsh's resolver library in xml-commons.
Appendable: Interface to be implemented by "appendable" resources.
AppendableResourceCollection: Interface describing a collection of Resources, to which elements can be appended.
Arc: Draw an arc.
Arc: Draw an arc.
Arc.ArcType
ArchiveFileSet: A ArchiveFileSet is a FileSet with extra attributes useful in the context of archiving tasks.
ArchiveResource: A Resource representation of an entry inside an archive.
Archives: A resource collection that treats all nested resources as archives and returns the contents of the archives as its content.
ArchiveScanner: ArchiveScanner accesses the pattern matching algorithm in DirectoryScanner, which are protected methods that can only be accessed by subclassing.
ArgumentProcessor: Processor of arguments of the command line.
ArgumentProcessorRegistry: The global registry for `ArgumentProcessor`s.
AsiExtraField: Adds Unix file permission and UID/GID fields as well as symbolic link handling.
Assertions: The assertion datatype.
Assertions.BaseAssertion: base class for our assertion elements.
Assertions.DisabledAssertion: A disabled assertion disables things
Assertions.EnabledAssertion: an enabled assertion enables things
Attrib: Attrib equivalent for Win32 environments.
AttributeNamespace: This class is used to indicate that the XML namespace (URI) can be used to look for namespace attributes.
AttributeNamespaceDef: Definition to allow the URI to be considered for Ant attributes.
AugmentReference: Ant task to dynamically augment a previously declared reference.
Available: Will set the given property if the requested resource is available at runtime.
Available.FileDir: EnumeratedAttribute covering the file types to be checked for, either file or dir.
Base64Converter: BASE 64 encoding of a String or an array of bytes.
BaseExtendSelector: Convenience base class for all selectors accessed through ExtendSelector.
BaseFilterReader: Base class for core filter readers.
BaseIfAttribute: An abstract class for if/unless attributes.
Basename: Sets a property to the base name of a specified file, optionally minus a suffix.
BaseParamFilterReader: Parameterized base class for core filter readers.
BaseResourceCollectionContainer: Base class for ResourceCollections that nest multiple ResourceCollections.
BaseResourceCollectionWrapper: Base class for a ResourceCollection that wraps a single nested ResourceCollection.
BaseSelector: A convenience base class that you can subclass Selectors from.
BaseSelectorContainer: This is the base class for selectors that can contain other selectors.
BaseTest: Baseclass for BatchTest and JUnitTest.
BasicShape: Draw a basic shape
BasicShape: Draw a basic shape
BatchTest: Create then run `JUnitTest`'s based on the list of files given by the fileset attribute.
BCFileSet: Utility FileSet that includes directories for backwards-compatibility with certain tasks e.g.
BigProjectLogger: This is a special logger that is designed to make it easier to work with big projects, those that use imports and subant to build complex systems.
BindTargets: Simple task which bind some targets to some defined extension point
BlockFor
BorlandDeploymentTool: BorlandDeploymentTool is dedicated to the Borland Application Server 4.5 and 4.5.1 This task generates and compiles the stubs and skeletons for all ejb described into the Deployment Descriptor, builds the jar file including the support files and verify whether the produced jar is valid or not.
BorlandGenerateClient: Generates a Borland Application Server 4.5 client JAR using as input the EJB JAR file.
BriefJUnitResultFormatter: Prints plain text output of the test to a specified Writer.
BuildEvent: Class representing an event occurring during a build.
BuildException: Signals an error condition during a build
BuildListener: Instances of classes that implement this interface can register to be notified when things happened during a build.
BuildLogger: Interface used by Ant to log the build output.
BuildNumber: Read, increment, and write a build number in a file It will first attempt to read a build number from a file, then set the property "build.number" to the value that was read in (or 0 if no such value).
BuildTimeoutException: This exception is used to indicate timeouts.
BuiltinNative2Ascii: Encapsulates the built-in Native2Ascii implementation.
BUnzip2: Expands a file that has been compressed with the BZIP2 algorithm.
BZip2: Compresses a file with the BZIP2 algorithm.
BZip2Constants: Base class for both the compress and decompress classes.
BZip2Resource: A Bzip2 compressed resource.
Cab: Create a CAB archive.
Cache: A Cache let the user store key-value-pairs in a permanent manner and access them.
CallTarget: Call another target in the same project.
CanCreateSymbolicLink: Tests whether the current process can create a symbolic link.
CBZip2InputStream: An input stream that decompresses from the BZip2 format (without the file header chars) to be read as any other stream.
CBZip2OutputStream: An output stream that compresses into the BZip2 format (without the file header chars) into another stream.
CCCheckin: Performs ClearCase checkin.
CCCheckout: Performs ClearCase checkout.
CCLock: Performs a ClearCase Lock command.
CCMCheck: Class common to all check commands (checkout, checkin,checkin default task);
CCMCheckin: Performs Continuus checkin command.
CCMCheckinDefault: Performs Continuus Checkin Default task command.
CCMCheckout: Performs Continuus checkout command.
CCMCreateTask: Creates new Continuus ccm task and sets it as the default.
CCMkattr: Task to perform mkattr command to ClearCase.
CCMkbl: Task to CreateBaseline command to ClearCase.
CCMkdir: Performs ClearCase mkdir.
CCMkelem: Performs ClearCase mkelem.
CCMklabel: Task to perform mklabel command to ClearCase.
CCMklbtype: Task to perform mklbtype command to ClearCase.
CCMReconfigure: Task allows to reconfigure a project, recursively or not
CCRmtype: Task to perform rmtype command to ClearCase.
CCUnCheckout: Performs ClearCase UnCheckout command.
CCUnlock: Performs a ClearCase Unlock command.
CCUpdate: Performs a ClearCase Update command.
CentralDirectoryParsingZipExtraField: `ZipExtraField` that knows how to parse central directory data.
ChainableReader: Interface indicating that a reader may be chained to another one.
ChainedMapper: A `ContainerMapper` that chains the results of the first nested `FileNameMapper`s into sourcefiles for the second, the second to the third, and so on, returning the resulting mapped filenames from the last nested `FileNameMapper`.
ChainReaderHelper: Process a FilterReader chain.
ChangeLogTask: Examines the output of cvs log and group related changes together.
ChangeLogWriter: Class used to generate an XML changelog.
CharSet: EnumeratedAttribute implementation for Charset to use with encoding/charset attributes.
Checksum: Used to create or verify file checksums.
Checksum.FormatElement: Helper class for the format attribute.
ChecksumAlgorithm: Computes a 'checksum' for the content of file using java.util.zip.CRC32 and java.util.zip.Adler32.
Chgrp: Chgrp equivalent for unix-like environments.
Chmod: Chmod equivalent for unix-like environments.
Chown: Chown equivalent for unix-like environments.
ClassConstants: Assembles the constants declared in a Java class in `key1=value1(line separator)key2=value2` format.
ClassCPInfo: The constant pool entry which stores class information.
ClassFile: A ClassFile object stores information about a Java class.
ClassFileIterator: Iterator interface for iterating over a set of class files
ClassfileSet: A ClassfileSet is a FileSet that enlists all classes that depend on a certain set of root classes.
ClassfileSet.ClassRoot: Inner class used to contain info about root classes.
ClassFileUtils: Utility class file routines.
Classloader: EXPERIMENTAL Create or modifies ClassLoader.
ClassNameReader: Provides a quick and dirty way to determine the true name of a class given just an InputStream.
ClasspathUtils: Offers some helper methods on the Path structure in ant.
ClasspathUtils.Delegate: Delegate that helps out any specific ProjectComponent that needs dynamic classloading.
ClearCase: A base class for creating tasks for executing commands on ClearCase.
CloseResources: Not a real task but used during tests.
CollectionUtils: Deprecated.
CollectionUtils.EmptyEnumeration<E>: Deprecated.
ColorMapper
ColorMapper
CommandLauncher: A command launcher for a particular JVM/OS platform.
CommandLauncherProxy: A command launcher that proxies another command launcher.
CommandLauncherTask: Task that configures the `CommandLauncher` to used when starting external processes.
Commandline: Commandline objects help handling command lines specifying processes to execute.
Commandline.Argument: Used for nested xml command line definitions.
CommandlineJava: A representation of a Java command line that is a composite of 2 `Commandline`s.
CommandlineJava.SysProperties: Specialized Environment class for System properties.
CommonsLoggingListener: Jakarta Commons Logging listener.
Compare: ResourceSelector that compares against "control" Resource(s) using ResourceComparators.
Comparison: EnumeratedAttribute for generic comparisons.
Compatability: Enum used in (@link Extension) to indicate the compatibility of one extension to another.
Compatibility: Enum used in (@link Extension) to indicate the compatibility of one extension to another.
CompilerAdapter: The interface that all compiler adapters must adhere to.
CompilerAdapterExtension: Extension interface for compilers that support source extensions other than .java.
CompilerAdapterFactory: Creates the necessary compiler adapter, given basic criteria.
Componentdef: Adds a component definition to the current project.
ComponentHelper: Component creation and configuration.
CompositeMapper: A `ContainerMapper` that unites the results of its constituent `FileNameMapper`s into a single set of result filenames.
CompressedResource: A compressed resource.
Concat: This class contains the 'concat' task, used to concatenate a series of files into a single stream.
Concat.TextElement: sub element points to a file or contains text
ConcatFileInputStream: Special `InputStream` that will concatenate the contents of an array of files.
ConcatFilter: Concats a file before and/or after the file.
ConcatResourceInputStream: Special `InputStream` that will concatenate the contents of Resources from a single ResourceCollection.
Condition: Interface for conditions to use inside the <condition> task.
ConditionBase: Baseclass for the <condition> task as well as several conditions - ensures that the types of conditions inside the task and the "container" conditions are in sync.
ConditionTask: Task to set a property conditionally using <uptodate>, <available>, and many other supported conditions.
ConstantCPInfo: A Constant Pool entry which represents a constant value.
ConstantPool: The constant pool of a Java class.
ConstantPoolEntry: An entry in the constant pool.
Constants: Constants, like filenames shared between various classes in this package.
Constants: Constants used within the junitlauncher task
ContainerMapper: A `FileNameMapper` that contains other `FileNameMapper`s.
Contains: Is one string part of another string?
ContainsRegexpSelector: Selector that filters files based on a regular expression.
ContainsSelector: Selector that filters files/resources based on whether they contain a particular string.
Content: Compares Resources by content.
ContentTransformingResource: A resource that transforms the content of another resource.
Continuus: A base class for creating tasks for executing commands on Continuus 5.1.
Copy: Copies a file or directory to a new file or directory.
Copydir: Deprecated. The copydir task is deprecated since Ant 1.2.
Copyfile: Deprecated. The copyfile task is deprecated since Ant 1.2.
CopyPath: Deprecated. this task should have never been released and was obsoleted by ResourceCollection support in Copy available since Ant 1.7.0.
CustomJUnit4TestAdapterCache: Provides a custom implementation of the notifier for a JUnit4TestAdapter so that skipped and ignored tests can be reported to the existing `TestListener`s.
CutDirsMapper: A mapper that strips of the a configurable number of leading directories from a file name.
Cvs: Performs operations on a CVS repository.
CVSEntry: CVS Entry.
CVSPass: Adds an new entry to a CVS password file.
CvsTagDiff: Examines the output of cvs rdiff between two tags.
CvsTagEntry: Holds the information of a line of rdiff
CvsUser: Represents a CVS user with a userID and a full name.

CvsVersion

this task allows to find out the client and the server version of a CVS installation example usage : <cvsversion cvsRoot=":pserver:anoncvs@cvs.apache.org:/home/cvspublic" passfile="c:/programme/cygwin/home/antoine/.cvspass" clientversionproperty="apacheclient" serverversionproperty="apacheserver" /> the task can be used also in the API by calling its execute method, then calling getServerVersion and/or getClientVersion

DataType: Base class for those classes that can appear inside the build file as stand alone data types.
Date: Compares Resources by last modification date.
Date: Date ResourceSelector.
DateSelector: Selector that chooses files based on their last modified date.
DateSelector.TimeComparisons: Enumerated attribute with the values for time comparison.
DateUtils: Helper methods to deal with date/time formatting with a specific defined format (ISO8601) or a correct pluralization of elapsed time in minutes and seconds.
DefaultCompilerAdapter: This is the default implementation for the CompilerAdapter interface.
DefaultDefinitions: Default definitions.
DefaultExcludes: Alters the default excludes for the entire build..
DefaultExecutor: Default Target executor implementation.
DefaultInputHandler: Prompts on System.err, reads input from System.in
DefaultJspCompilerAdapter: This is the default implementation for the JspCompilerAdapter interface.
DefaultLogger: Writes build events to a PrintStream.
DefaultNative2Ascii: encapsulates the handling common to different Native2AsciiAdapter implementations.
DefaultRmicAdapter: This is the default implementation for the RmicAdapter interface.
DefBase: Base class for Definitions handling uri and class loading.
Definer: Base class for Taskdef and Typedef - handles all the attributes for Typedef.
Definer.Format: Enumerated type for format attribute
Definer.OnError: Enumerated type for onError attribute
DelegatedResourceComparator: Delegates to other ResourceComparators or, if none specified, uses Resources' natural ordering.
Delete: Deletes a file or directory, or set of files defined by a fileset.
Deltree: Deprecated. The deltree task is deprecated since Ant 1.2.
DemuxInputStream: Passes input requests to the project object for demultiplexing into individual tasks and threads.
DemuxOutputStream: Logs content written by a thread and forwards the buffers onto the project object which will forward the content to the appropriate task.
Depend: Generates a dependency file for a given set of classes.
DependencyAnalyzer: A dependency analyzer analyzes dependencies between Java classes to determine the minimal set of classes which are required by a set of "root" classes.
DependencyVisitor: A BCEL visitor implementation to collect class dependency information
DependScanner: DirectoryScanner for finding class dependencies.
DependSelector: Selector that filters files based on whether they are newer than a matching file in another directory tree.
DependSet: Examines and removes out of date target files.
DepthSelector: Selector that filters files based on the how deep in the directory tree they are.
Description: Description is used to provide a project-wide description element (that is, a description that applies to a buildfile as a whole).
DescriptorHandler: Inner class used by EjbJar to facilitate the parsing of deployment descriptors and the capture of appropriate information.
DeweyDecimal: Deprecated. use org.apache.tools.ant.util.DeweyDecimal instead.
DeweyDecimal: Utility class to contain version numbers in "Dewey Decimal" syntax.
Diagnostics: A little diagnostic helper that output some information that may help in support.
DiagnosticsTask: This is a task that hands off work to the Diagnostics module.
Difference: ResourceCollection representing the difference between two or more nested ResourceCollections.
DifferentSelector: This selector selects files against a mapped set of target files, selecting all those files which are different.
DigestAlgorithm: Computes a 'hashvalue' for the content of file using java.security.MessageDigest.
Directory: A helper object for Scp representing a directory in a file system.
DirectoryIterator: An iterator which iterates through the contents of a java directory.
DirectoryScanner: Class for scanning a directory for files/directories which match certain criteria.
Dirname: Determines the directory name of the specified file.
DirSet: Subclass as hint for supporting tasks that the included directories instead of files should be used.
Dispatchable: Classes implementing this interface specify the name of the parameter that contains the name of the task's method to execute.
DispatchTask: Tasks extending this class may contain multiple actions.
DispatchUtils: Determines and Executes the action method for the task.
DOMElementWriter: Writes a DOM tree to a given Writer.
DOMElementWriter.XmlNamespacePolicy: Whether namespaces should be ignored for elements and attributes.
DOMUtil: Some utilities that might be useful when manipulating DOM trees.
DOMUtil.NodeFilter: Filter interface to be applied when iterating over a DOM tree.
DOMUtil.NodeListImpl: custom implementation of a nodelist
DOMUtils: Some utility methods for common tasks when building DOM trees in memory.
DoubleCPInfo: The constant pool entry subclass used to represent double constant values.
Draw
Draw
DrawOperation: Interface which represents an Operation which is "drawable", such as a Rectangle, Circle or Text.
DrawOperation: Interface which represents an Operation which is "drawable", such as a Rectangle, Circle or Text.
DTDLocation: Helper class to handle the DTD nested element.
DynamicAttribute: Enables a task to control unknown attributes
DynamicAttributeNS: Enables a task to control unknown attributes.
DynamicConfigurator: Enables a task to control unknown attributes and elements.
DynamicConfiguratorNS: Enables a task to control unknown attributes and elements.
DynamicCPInfo: An Dynamic CP Info
DynamicElement: Enables a task to control unknown elements.
DynamicElementNS: Enables a task to control unknown elements.
DynamicObjectAttribute: Enables a task to control unknown attributes.
Ear: Creates a EAR archive.
Echo: Writes a message to the Ant logging facilities.
Echo.EchoLevel: The enumerated values for the level attribute.
EchoProperties: Displays all the current properties in the build.
EchoProperties.FormatAttribute: A enumerated type for the format attribute.
EchoXML: Echo XML.
EchoXML.NamespacePolicy
EJBDeploymentTool: The interface to implement for deployment tools.
EjbJar: Provides automated EJB JAR file creation.
EjbJar.CMPVersion: CMP versions supported valid CMP versions are 1.0 and 2.0
EjbJar.DTDLocation: Inner class used to record information about the location of a local DTD
EjbJar.NamingScheme: An EnumeratedAttribute class for handling different EJB jar naming schemes
Ellipse: Draw an ellipse.
Ellipse: Draw an ellipse.
EmailAddress: Holds an email address.
EmailTask: A task to send SMTP email.
EmailTask.Encoding: Enumerates the encoding constants.
EnableAttribute: This interface is used by Ant attributes.
EnumeratedAttribute: Helper class for attributes that can only take one of a fixed list of values.
Enumerations: Deprecated.
Environment: Wrapper for environment variables.
Environment.Variable: representation of a single env value
EqualComparator: Simple implementation of Comparator for use in CacheSelector.
Equals: Simple comparison condition.
ErrorInQuitException: Specialized IOException that get thrown if SMTP's QUIT command fails.
EscapeUnicode: This method converts non-latin characters to unicode escapes.
Evaluable<T>: Kind of task attribute that can be evaluated before being assigned
Exec: Deprecated. since 1.2.
ExecTask: Executes a given command if the os platform is appropriate.
ExecutableSelector: A selector that selects executable files.
Execute: Runs an external program.
ExecuteJava: Execute a Java class.
ExecuteOn: Executes a given command, supplying a set of files as arguments.
ExecuteOn.FileDirBoth: Enumerated attribute with the values "file", "dir" and "both" for the type attribute.
ExecuteStreamHandler: Used by `Execute` to handle input and output stream of subprocesses.
ExecuteWatchdog: Destroys a process running for too long.
Executor: Target executor abstraction.
Exists: Compares Resources by existence.
Exists: Exists ResourceSelector.
Exit: Exits the active build, giving an additional message if available.
ExitException: Used to report exit status of classes which call System.exit().
ExitStatusException: BuildException + exit status.
Expand: Unzip a file.
ExpandProperties: Expands Ant properties, if any, in the data.
ExtendFileSelector: This is the interface to be used by all custom selectors, those that are called through the <custom> tag.
ExtendSelector: Selector that selects files by forwarding the request on to other classes.
Extension: Utility class that represents either an available "Optional Package" (formerly known as "Standard Extension") as described in the manifest of a JAR file, or the requirement for such an optional package.
ExtensionAdapter: Simple class that represents an Extension and conforms to Ants patterns.
ExtensionPoint: An extension point build files can provide as a place where other build files can add new dependencies.
ExtensionResolver: Interface to locate a File that satisfies extension.
ExtensionSet: The Extension set lists a set of "Optional Packages" / "Extensions".
ExtensionUtil: A set of useful methods relating to extensions.
ExtraAttribute: Simple holder for extra attributes in main section of manifest.
ExtraFieldUtils: ZipExtraField related methods
ExtraFieldUtils.UnparseableExtraField: "enum" for the possible actions to take if the extra field cannot be parsed.
FacadeTaskHelper: Helper class for facade implementations - encapsulates treatment of explicit implementation choices, magic properties and implementation specific command line arguments.
FailureRecorder: Collects all failing test cases and creates a new JUnit test class containing a suite() method which calls these failed tests.
FailureRecorder.TestInfos: TestInfos holds information about a given test for later use.
FieldRefCPInfo: A FieldRef CP Info
FileList: FileList represents an explicitly named list of files.
FileList.FileName: Inner class corresponding to the <file> nested element.
FileNameMapper: Interface to be used by SourceFileScanner.
FilenameSelector: Selector that filters files based on the filename.
FileProvider: This is an interface that resources that can provide a file should implement.
FileResource: A Resource representation of a File.
FileResourceIterator: Iterator of FileResources from filenames.
Files: ResourceCollection implementation; like AbstractFileSet with absolute paths.
FileScanner: An interface used to describe the actions required of any type of directory scanner.
FileSelector: This is the interface to be used by all selectors.
FileSet: Moved out of MatchingTask to make it a standalone object that could be referenced (by scripts for example).
FilesMatch: Compares two files for equality based on size and content.
FileSystem: Compares filesystem Resources.
FileTokenizer: Class to read the complete input into a string.
FileUtils: This class also encapsulates methods which allow Files to be referred to using abstract path names which are translated to native system file paths at runtime as well as copying files or setting their last modification time.
Filter: Sets a token filter that is used by the file copy tasks to do token substitution.
FilterChain: FilterChain may contain a chained set of filter readers.
FilterMapper: This is a FileNameMapper based on a FilterChain.
FilterSet: A set of filters to be applied to something.
FilterSet.Filter: Individual filter component of filterset.
FilterSet.OnMissing: EnumeratedAttribute to set behavior WRT missing filtersfiles: "fail" (default), "warn", "ignore".
FilterSetCollection: A FilterSetCollection is a collection of filtersets each of which may have a different start/end token settings.
First: ResourceCollection that contains the first `count` elements of another ResourceCollection, a la the UNIX head command.
FirstMatchMapper: A `ContainerMapper` that returns the results of its first constituent `FileNameMapper`s that matches.
FixCRLF: Converts text source files to local OS formatting conventions, as well as repair text files damaged by misconfigured or misguided editors or file transfer programs.
FixCRLF.AddAsisRemove: Enumerated attribute with the values "asis", "add" and "remove".
FixCRLF.CrLf: Enumerated attribute with the values "asis", "cr", "lf", "crlf", "mac", "unix" and "dos.
FixCrLfFilter: Converts text to local OS formatting conventions, as well as repair text damaged by misconfigured or misguided editors or file transfer programs.
FixCrLfFilter.AddAsisRemove: Enumerated attribute with the values "asis", "add" and "remove".
FixCrLfFilter.CrLf: Enumerated attribute with the values "asis", "cr", "lf" and "crlf".
FlatFileNameMapper: Implementation of FileNameMapper that always returns the source file name without any leading directory information.
FlexInteger: Helper class which can be used for Ant task attribute setter methods to allow the build file to specify an integer in either decimal, octal, or hexadecimal format.
FloatCPInfo: A Float CP Info
ForkDefinition: Represents the `fork` element within test definitions of the `junitlauncher` task
ForkDefinition.ForkMode
ForkingJavah: This implementation runs the javah executable in a separate process.
ForkingSunRmic: This is an extension of the sun rmic compiler, which forks rather than executes it inline.
FormatterElement: A wrapper for the implementations of `JUnitResultFormatter`.
FormatterElement.TypeAttribute: Enumerated attribute with the values "plain", "xml", "brief" and "failure".
FTP: Basic FTP client.
FTP.Action: an action to perform, one of "send", "put", "recv", "get", "del", "delete", "list", "mkdir", "chmod", "rmdir"
FTP.FTPFileProxy: internal class providing a File-like interface to some of the information available from the FTP server
FTP.FTPSystemType: one of the valid system type keys recognized by the systemTypeKey attribute.
FTP.Granularity: represents one of the valid timestamp adjustment values recognized by the `timestampGranularity` attribute.
FTP.LanguageCode: Enumerated class for languages.
FTPTask: Basic FTP client.
FTPTask.Action: an action to perform, one of "send", "put", "recv", "get", "del", "delete", "list", "mkdir", "chmod", "rmdir"
FTPTask.FTPSystemType: one of the valid system type keys recognized by the systemTypeKey attribute.
FTPTask.Granularity: represents one of the valid timestamp adjustment values recognized by the `timestampGranularity` attribute.
FTPTaskMirror
FTPTaskMirrorImpl
FTPTaskMirrorImpl.FTPFileProxy: internal class providing a File-like interface to some of the information available from the FTP server
FullAnalyzer: An analyzer capable fo traversing all class - class relationships.

Funtest

Task to provide functional testing under Ant, with a fairly complex workflow of: Conditional execution Application to start A probe to "waitfor" before running tests A tests sequence A reporting sequence that runs after the tests have finished A "teardown" clause that runs after the rest. Automated termination of the program it executes, if a timeout is not met Checking of a failure property and automatic raising of a fault (with the text in failureText) if test shutdown and reporting succeeded The task is designed to be framework neutral; it will work with JUnit, TestNG and other test frameworks That can be executed from Ant.

Gcj: The implementation of the gcj compiler.
Gcjh: Adapter to the native gcjh compiler.
GeneralPurposeBit: Parser/encoder for the "general purpose bit" field in ZIP's local file and central directory headers.
GenerateKey: Generates a key in a keystore.
GenerateKey.DistinguishedName: A class corresponding to the dname nested element.
GenerateKey.DnameParam: A DistinguishedName parameter.
GenericDeploymentTool: A deployment tool which creates generic EJB jars.
GenericHotDeploymentTool: A generic tool for J2EE server hot deployment.
Get: Gets a particular file from a URL source.
Get.Base64Converter: Provide this for Backward Compatibility.
Get.DownloadProgress: Interface implemented for reporting progress of downloading.
Get.NullProgress: do nothing with progress info
Get.VerboseProgress: verbose progress system prints to some output stream
GetProperty: Interface to a class (normally PropertyHelper) to get a property.
GlobPatternMapper: Implementation of FileNameMapper that does simple wildcard pattern replacements.
GreedyInputHandler: Prompts on System.err, reads input from System.in until EOF
GUnzip: Expands a file that has been compressed with the GZIP algorithm.
GZip: Compresses a file with the GZIP algorithm.
GZipResource: A GZip compressed resource.
HasFreeSpace: <hasfreespace>
HashvalueAlgorithm: Computes a 'hashvalue' for the content of file using String.hashValue().
HasMethod: test for a method
Header: Class representing a generic key-value header.
HeadFilter: Reads the first `n` lines of a stream.
HostInfo: Sets properties to the host provided, or localhost if no information is provided.
HotDeploymentTool: An interface for vendor-specific "hot" deployment tools.
Http: Condition to wait for a HTTP request to succeed.
IdentityMapper: Implementation of FileNameMapper that always returns the source file name.
IdentityStack<E>: Identity Stack.
IfBlankAttribute: Check if an attribute is blank or not.
IfBlankAttribute.Unless: The unless version
IfSetAttribute: Check if an attribute value as a property is set or not
IfSetAttribute.Unless: The unless version
IfTrueAttribute: Check if an attribute value is true or not.
IfTrueAttribute.Unless: The unless version
IgnoreDependenciesExecutor: Target executor implementation that ignores dependencies.
IgnoredTestListener: Provides the functionality for TestListeners to be able to be notified of the necessary JUnit4 events for test being ignored (@Ignore annotation) or skipped (Assume failures).
IgnoredTestResult: Records ignored and skipped tests reported as part of the execution of JUnit 4 tests.
Image: Deprecated. JAI is not developed any more.
ImageIOTask: A MatchingTask which relies on Java ImageIO to read existing image files and write the results of AWT image manipulation operations.
ImageIOTask.ImageFormat: defines acceptable image formats.
ImageOperation
ImageOperation
ImmutableResourceException: Exception thrown when an attempt is made to get an OutputStream from an immutable Resource.
ImplementationSpecificArgument: Extension of Commandline.Argument with a new attribute that chooses a specific implementation of the facade.
ImportTask: Task to import another build file into the current project.
InnerClassFilenameFilter: A filename filter for inner class files of a particular class.
Input: Reads an input line from the console.
Input.HandlerType: EnumeratedAttribute representing the built-in input handler types: "default", "propertyfile", "greedy", "secure" (since Ant 1.8).
InputHandler: Plugin to Ant to handle requests for user input.
InputRequest: Encapsulates an input request.
InstanceOf: InstanceOf ResourceSelector.
IntegerCPInfo: An Integer CP Info
InterfaceMethodRefCPInfo: A InterfaceMethodRef CP Info
Intersect: ResourceCollection representing the intersection of multiple nested ResourceCollections.
IntrospectionHelper: Helper class that collects the methods a task or nested element holds to set attributes, create nested elements or hold PCDATA elements.
IntrospectionHelper.Creator: creator - allows use of create/store external to IntrospectionHelper.
InVMExecution: Used during in-vm (non-forked mode) launching of tests
InvokeDynamicCPInfo: An InvokeDynamic CP Info
IPlanetDeploymentTool: This class is used to generate iPlanet Application Server (iAS) 6.0 stubs and skeletons and build an EJB Jar file.
IPlanetEjbc: Compiles EJB stubs and skeletons for the iPlanet Application Server (iAS).
IPlanetEjbcTask: Compiles EJB stubs and skeletons for the iPlanet Application Server.
IsFailure: Condition to test a return-code for failure.
IsFalse: Condition that tests whether a given string evals to false
IsFileSelected: This is a condition that checks to see if a file passes an embedded selector.
IsLastModified: Condition that makes assertions about the last modified date of a resource.
IsLastModified.CompareMode: describes comparison modes.
IsReachable: Test for a host being reachable using ICMP "ping" packets & echo operations.
IsReference: Condition that tests whether a given reference has been defined.
IsSet: Condition that tests whether a given property has been set.
IsSigned: Checks whether a jarfile is signed: if the name of the signature is passed, the file is checked for presence of that particular signature; otherwise the file is checked for the existence of any signature.
IsTrue: Condition that tests whether a given string evals to true
JakartaMimeMailer: Uses the JakartaMail classes to send Mime format email.
JakartaOroMatcher: Implementation of RegexpMatcher for Jakarta-ORO.
JakartaOroRegexp: Regular expression implementation using the Jakarta Oro package
JakartaRegexpMatcher: Implementation of RegexpMatcher for Jakarta-Regexp.
JakartaRegexpRegexp: Regular expression implementation using the Jakarta Regexp package
Jar: Creates a JAR archive.
Jar.FilesetManifestConfig: The manifest config enumerated type.
Jar.StrictMode: The strict enumerated type.
JarFileIterator: A class file iterator which iterates through the contents of a Java jar file.
JarLibAvailableTask: Checks whether an extension is present in a fileset or an extensionSet.
JarLibDisplayTask: Displays the "Optional Package" and "Package Specification" information contained within the specified JARs.
JarLibManifestTask: Generates a manifest that declares all the dependencies.
JarLibResolveTask: Tries to locate a JAR to satisfy an extension and place location of JAR into property.
JarMarker: If this extra field is added as the very first extra field of the archive, Solaris will consider it an executable jar file.
Jasper41Mangler: this class implements the name mangling rules of the jasper in tomcat4.1.x which is likely to remain for some time
JasperC: The implementation of the jasper compiler.
Java: Launcher for Java applications.
Java13CommandLauncher: A command launcher for JDK/JRE 1.3 (and higher).
Javac: Compiles Java source files.
Javac12: Deprecated. Use `Javac13` instead.
Javac13: The implementation of the javac compiler for JDK 1.3 This is primarily a cut-and-paste from the original javac task before it was refactored.
JavaCC: JavaCC compiler compiler task.
JavacExternal: Performs a compile using javac externally.
JavaClassHelper: Helper class that filters constants from a Java Class
JavaConstantResource: A resource that is a java constant.
Javadoc: Generates Javadoc documentation for a collection of source code.
Javadoc.AccessType: EnumeratedAttribute implementation supporting the Javadoc scoping values.
Javadoc.ExtensionInfo: A project aware class used for Javadoc extensions which take a name and a path such as doclet and taglet arguments.
Javadoc.Html: An HTML element in the Javadoc.
Javadoc.PackageName: Used to track info about the packages to be javadoc'd
Javadoc.SourceFile: This class is used to manage the source files to be processed.
JavaEnvUtils: A set of helper methods related to locating executables or checking conditions of a given Java installation.
Javah: Generates JNI header files using javah.
JavahAdapter: Interface for different backend implementations of the Javah task.
JavahAdapterFactory: Creates the JavahAdapter based on the user choice and potentially the VM vendor.
JavaResource: A Resource representation of something loadable via a Java classloader.
JavaVersion: An Java version condition.
JavaxScriptRunner: This class is used to run scripts using JSR 223.
JAXPUtils: Collection of helper methods that retrieve a ParserFactory or Parsers and Readers.
JbossDeploymentTool: The deployment tool to add the jboss specific deployment descriptor to the ejb jar file.
JDBCTask: Handles JDBC configuration needed by SQL type tasks.
JDependTask: Runs JDepend tests.
JDependTask.FormatAttribute: A class for the enumerated attribute format, values are xml and text.
Jdk14RegexpMatcher: Implementation of RegexpMatcher for the built-in regexp matcher of JDK 1.4.
Jdk14RegexpRegexp: Regular expression implementation using the JDK 1.4 regular expression package
Jikes: The implementation of the jikes compiler.
Jikes: Deprecated. since 1.2.
JikesOutputParser: Deprecated. since 1.2.
JJDoc: Runs the JJDoc compiler compiler.
JJTree: Runs the JJTree compiler compiler.
jlink: jlink links together multiple .jar files.
JlinkTask: This task defines objects that can link together various jar and zip files.
Jmod: Creates a linkable .jmod file from a modular jar file, and optionally from other resource files such as native libraries and documents.
Jmod.ResolutionWarningReason: Permissible reasons for jmod creation to emit warnings.
JonasDeploymentTool: The deployment tool to add the jonas specific deployment descriptors to the ejb JAR file.
JonasHotDeploymentTool: An Ant wrapper task for the weblogic.deploy tool.
JspC: Runs a JSP compiler.
JspC.WebAppParameter: static inner class used as a parameter element
JspCompilerAdapter: The interface that all jsp compiler adapters must adhere to.
JspCompilerAdapterFactory: Creates the necessary compiler adapter, given basic criteria.
JspMangler: This is an interface to the Mangler service that jspc needs to map JSP file names to java files.
JspNameMangler: This is a class derived from the Jasper code (org.apache.jasper.compiler.CommandLineCompiler) to map from a JSP filename to a valid Java classname.
JUnit4TestMethodAdapter: Adapter between JUnit 3.8.x API and JUnit 4.x API for execution of tests and listening of events (test start, test finish, test failure, test skipped).
JUnitLauncherTask: An Ant `Task` responsible for launching the JUnit platform for running tests.
JUnitResultFormatter: This Interface describes classes that format the results of a JUnit testrun.
JUnitTask: Runs JUnit tests.
JUnitTask.ForkMode: These are the different forking options
JUnitTask.JUnitLogOutputStream: A stream handler for handling the junit task.
JUnitTask.JUnitLogStreamHandler: A log stream handler for junit.
JUnitTask.SummaryAttribute: Print summary enumeration values.
JUnitTask.TestResultHolder: A value class that contains the result of a test.
JUnitTaskMirror: Handles the portions of `JUnitTask` which need to directly access actual JUnit classes, so that junit.jar need not be on Ant's startup classpath.
JUnitTaskMirror.JUnitResultFormatterMirror: The interface that JUnitResultFormatter extends.
JUnitTaskMirror.JUnitTestRunnerMirror: Interface that test runners implement.
JUnitTaskMirror.SummaryJUnitResultFormatterMirror: The interface that SummaryJUnitResultFormatter extends.
JUnitTaskMirrorImpl: Implementation of the part of the junit task which can directly refer to junit.* classes.
JUnitTest: Run a single JUnit test.
JUnitTestRunner: Simple Testrunner for JUnit that runs all tests of a testsuite.
JUnitVersionHelper: Work around for some changes to the public JUnit API between different JUnit releases.
Jvc: The implementation of the jvc compiler from microsoft.
Kaffeh: Adapter to the native kaffeh compiler.
KaffeNative2Ascii: Adapter to kaffe.tools.native2ascii.Native2Ascii.
KaffeRmic: The implementation of the rmic for Kaffe
KeepAliveInputStream: Class that can be used to wrap `System.in` without getting anxious about any client closing the stream.
KeepAliveOutputStream: Class that can be used to wrap `System.out` and `System.err` without getting anxious about any client closing the stream.
KeySubst: Deprecated. KeySubst is deprecated since Ant 1.1.
Kjc: The implementation of the Java compiler for KJC.
Last: ResourceCollection that contains the last `count` elements of another ResourceCollection, a la the UNIX tail command.
LastModifiedAlgorithm: Computes a 'timestamp' of file based on the lastModified time of that file.
LaunchDefinition: Defines the necessary context for launching the JUnit platform for running tests.
Launcher: This is a launcher for Ant.
LauncherSupport: Responsible for doing the real work involved in launching the JUnit platform and passing it the relevant tests that need to be executed by the JUnit platform.
LaunchException: Signals an error condition during launching
LayoutPreservingProperties: A Properties collection which preserves comments and whitespace present in the input stream from which it was loaded.
LazyFileOutputStream: Class that delays opening the output file until the first bytes shall be written or the method `open` has been invoked explicitly.
LazyHashtable<K,​V>: Deprecated.
LazyResourceCollectionWrapper: Resource collection which load underlying resource collection only on demand with support for caching
LeadPipeInputStream: Special `PipedInputStream` that will not die when the writing `Thread` is no longer alive.
Length: Gets lengths: of files/resources, byte size; of strings, length (optionally trimmed).
Length.FileMode: EnumeratedAttribute operation mode
Length.When: EnumeratedAttribute for the when attribute.
LibFileSet: LibFileSet represents a fileset containing libraries.
LineContains: Filter which includes only those lines that contain the user-specified strings.
LineContains.Contains: Holds a contains element
LineContainsRegExp: Filter which includes only those lines that contain the user-specified regular expression matching strings.
LineOrientedOutputStream: Invokes `processLine` whenever a full line has been written to this stream.
LineOrientedOutputStreamRedirector: Output stream which buffer and redirect a stream line by line.
LineTokenizer: class to tokenize the input as lines separated by \r (mac style), \r\n (dos/windows style) or \n (unix style)
Link: Assembles jmod files into an executable image.
Link.CompressionLevel: Possible attribute values for compression level of a linked image: `0` `none` no compression (default) `1` `strings` constant string sharing `2` `zip` zip compression
Link.Endianness: Possible values for linked image endianness: `little` and `big`.
Link.VMType: Possible values for JVM type in linked image: `client`, `server`, `minimal`, or `all`.
LinkedHashtable<K,​V>: Subclass of Hashtable that wraps a LinkedHashMap to provide predictable iteration order.
ListenerDefinition: Represents the `&lt;listener&gt;` element within the `&lt;junitlauncher&gt;` task
ListenerDefinition.ListenerType: defines available listener types.
LoaderUtils: ClassLoader utility methods
LoadFile: Load a file into a property
LoadProperties: Load a file's contents as Ant properties.
LoadResource: Load a resource into a property
Local: Task to create local properties in the current scope.
Local.Name: Nested `name` element.
LocalProperties: Thread local class containing local properties.
LocalPropertyStack: A stack of local property maps.
Location: Stores the location of a piece of text within a file (file name, line number and column number).
LocationResolver: Resolver that just returns s specified location.
Locator: The Locator is a utility class which is used to find certain items in the environment.
Log4jListener: Deprecated. Apache Log4j (1) is not developed any more.
LogLevel: The enumerated values for Ant's log level.
LogListener: Interface for ssh log listeners to implement.
LogOutputResource: Output-only Resource that always appends to Ant's log.
LogOutputStream: Logs each line written to this stream to the log system of ant.
LogStreamHandler: Logs standard output and error of a subprocess to the log system of ant.
LongCPInfo: A Long CP Info
MacCommandLauncher: A command launcher for Mac that uses a dodgy mechanism to change working directory before launching commands.
MacroDef: Describe class `MacroDef` here.
MacroDef.Attribute: An attribute for the MacroDef task.
MacroDef.NestedSequential: The class corresponding to the sequential nested element.
MacroDef.TemplateElement: A nested element for the MacroDef task.
MacroDef.Text: A nested text element for the MacroDef task.
MacroInstance: The class to be placed in the ant type definition.
MacroInstance.Element: Embedded element in macro instance
MagicNames: Magic names used within Ant.
Mailer: Base class for the various emailing implementations.
MailLogger: Buffers log messages from DefaultLogger, and sends an e-mail with the results.
MailMessage: A class to help send SMTP email.
Main: Command line entry point into Ant.
Majority: Majority ResourceSelector.
MajoritySelector: This selector is here just to shake up your thinking a bit.
MakeUrl: This task takes file and turns them into a URL, which it then assigns to a property.
Manifest: Holds the data of a jar manifest.
Manifest.Attribute: An attribute for the manifest.
Manifest.Section: A manifest section - you can nest attribute elements into sections.
ManifestClassPath: Converts a Path into a property suitable as a Manifest classpath.
ManifestException: Exception thrown indicating problems in a JAR Manifest
ManifestTask: Creates a manifest file for inclusion in a JAR, Ant task wrapper around `Manifest`.
ManifestTask.Mode: Helper class for Manifest's mode attribute.
MappedResource: A decorator around a different resource that uses a mapper to dynamically remap the resource's name.
MappedResourceCollection: Wrapper around a resource collections that maps the names of the other collection using a configured mapper.
Mapper: Element to define a FileNameMapper.
Mapper.MapperType: Class as Argument to FileNameMapper.setType.
MappingSelector: A mapping selector is an abstract class adding mapping support to the base selector
Matches: Simple regular expression condition.
MatchingTask: This is an abstract task that should be used by all those tasks that require to include or exclude files based on pattern matching.
MergingMapper: Implementation of FileNameMapper that always returns the same target file name.
Message: Class representing an email message.
MethodHandleCPInfo: A MethodHandle CP Info
MethodHandleCPInfo.ReferenceKind
MethodRefCPInfo: A MethodRef CP Info
MethodTypeCPInfo: A Method Type CP Info
MimeMail: Deprecated. since 1.6.x.
MimeMailer: Deprecated. see org.apache.tools.ant.taskdefs.email.JakartaMimeMailer
Mkdir: Creates a given directory.
Mklink: Runs mklink on Win32 systems.
Mklink.LinkType
ModifiedSelector: Selector class that uses Algorithm, Cache and Comparator for its work.
ModifiedSelector.AlgorithmName: The enumerated type for algorithm.
ModifiedSelector.CacheName: The enumerated type for cache.
ModifiedSelector.ComparatorName: The enumerated type for algorithm.
ModuleCPInfo: Represents the module info constant pool entry
ModuleVersion: Element describing the parts of a Java module version.
Move: Moves a file or directory to a new file or directory.
MSVSS: A base class for creating tasks for executing commands on Visual SourceSafe.
MSVSS.CurrentModUpdated: Extension of EnumeratedAttribute to hold the values for file time stamp.
MSVSS.WritableFiles: Extension of EnumeratedAttribute to hold the values for writable filess.
MSVSSADD: Performs Add commands to Microsoft Visual SourceSafe.
MSVSSCHECKIN: Performs CheckIn commands to Microsoft Visual SourceSafe.
MSVSSCHECKOUT: Performs CheckOut commands to Microsoft Visual SourceSafe.
MSVSSConstants: Holds all the constants for the VSS tasks.
MSVSSCP: Performs CP (Change Project) commands to Microsoft Visual SourceSafe.
MSVSSCREATE: Creates a new project in Microsoft Visual SourceSafe.
MSVSSGET: Perform Get commands from Microsoft Visual SourceSafe.
MSVSSHISTORY: Performs History commands to Microsoft Visual SourceSafe.
MSVSSHISTORY.BriefCodediffNofile: Extension of EnumeratedAttribute to hold the values for style.
MSVSSLABEL: Performs Label commands to Microsoft Visual SourceSafe.
MultipleChoiceInputRequest: Encapsulates an input request.
MultiRootFileSet: Union of file/dirsets that share the same patterns and selectors but have different roots.
MultiRootFileSet.SetType: What to return from the set: files, directories or both.
Name: Compares Resources by name.
Name: Name ResourceSelector.
NameAndTypeCPInfo: A NameAndType CP Info
NamedTest: A test that has a name associated with it
Native2Ascii: Converts files from native encodings to ASCII.
Native2AsciiAdapter: Interface for an adapter to a native2ascii implementation.
Native2AsciiAdapterFactory: Creates the Native2AsciiAdapter based on the user choice and potentially the VM vendor.
Native2AsciiFilter: A filter that performs translations from characters to their Unicode-escape sequences and vice-versa.
Native2AsciiUtils: Contains helper methods for Ant's built-in implementation of native2ascii.
NetRexxC: Compiles NetRexx source files.
NetRexxC.TraceAttr: Enumerated class corresponding to the trace attribute.
NetRexxC.VerboseAttr: Enumerated class corresponding to the verbose attribute.
Nice: A task to provide "nice-ness" to the current thread, and/or to query the current value.
NoBannerLogger: Extends DefaultLogger to strip out empty targets.
NoExitSecurityManager: This is intended as a replacement for the default system manager.
None: None ResourceSelector.
NoneSelector: This selector has a collection of other selectors.
Not: <not> condition.
Not: Not ResourceSelector.
NotSelector: This selector has one other selectors whose meaning it inverts.
NullOutputStream: OutputStream that completely discards all data written to it.
NullReturn: Class to represent a null and to stop the chain of lookups.
Or: <or> condition container.
Or: Or ResourceSelector.
OrionDeploymentTool: The deployment tool to add the orion specific deployment descriptor to the ejb jar file.
OrSelector: This selector has a collection of other selectors, any of which have to select a file in order for this selector to select it.
Os: Condition that tests the OS type.
OS2CommandLauncher: A command launcher for OS/2 that uses 'cmd.exe' when launching commands in directories other than the current working directory.
OutErrSummaryJUnitResultFormatter: Used instead of SummaryJUnitResultFormatter in forked tests if withOutAndErr is requested.
OutputStreamFunneler: Manages a set of `OutputStream`s to write to a single underlying stream, which is closed only when the last "funnel" has been closed.
OwnedBySelector: A selector that selects files based on their owner.
Pack: Abstract Base class for pack tasks.
PackageCPInfo: Represents the package info (within a module) constant pool entry
PackageNameMapper: Maps directory name matches into a dotted package name.
Parallel: Executes the contained tasks in separate threads, continuing once all are completed.
Parallel.TaskList: Class which holds a list of tasks to execute
Parameter: A parameter is composed of a name, type and value.
Parameterizable: Parameterizable objects take generic key value pairs.
ParseNextProperty: Helper for `PropertyExpander` that can be used to expand property references to values.
ParseProperties: Parse properties using a collection of expanders.
ParserSupports: Test for the XML parser supporting a particular feature
Patch: Patches a file by applying a 'diff' file to it; requires "patch" to be on the execution path.
Path: This object represents a path as used by CLASSPATH or PATH environment variable.
PathConvert: Converts path and classpath information to a specific target OS format.
PathConvert.TargetOs: An enumeration of supported targets: "windows", "unix", "netware", and "os/2".
PathTokenizer: A Path tokenizer takes a path and returns the components that make up that path.
PatternSet: Named collection of include/exclude tags.
PerlScriptCommandLauncher: A command launcher that uses an auxiliary perl script to launch commands in directories other than the current working directory.
Permissions: This class implements a security manager meant for usage by tasks that run inside the Ant VM.
Permissions.Permission: Represents a permission.
PermissionUtils: Contains helper methods for dealing with `PosixFilePermission` or the traditional Unix mode representation of permissions.
PermissionUtils.FileType: The supported types of files, maps to the `isFoo` methods in `BasicFileAttributes`.
PlainJUnitResultFormatter: Prints plain text output of the test to a specified Writer.
PosixGroupSelector: A selector that selects files based on their POSIX group.
PosixPermissionsSelector: A selector that selects files based on their POSIX permissions.
PrefixLines: Attaches a prefix to every line.
PresentSelector: Selector that filters files based on whether they appear in another directory tree.
PresentSelector.FilePresence: Enumerated attribute with the values for indicating where a file's presence is allowed and required.
PreSetDef: The preset definition task generates a new definition based on a current definition with some attributes or elements preset.
PreSetDef.PreSetDefinition: This class contains the unknown element and the object that is predefined.
ProcessUtil: Process Utilities
ProfileLogger: This is a special logger that is designed to profile builds.
Project: Central representation of an Ant project.
ProjectComponent: Base class for components of a project, including tasks and data types.
ProjectHelper: Configures a Project (complete with Targets and Tasks) based on a build file.
ProjectHelper.OnMissingExtensionPoint: Possible value for target's onMissingExtensionPoint attribute.
ProjectHelper2: Sax2 based project reader
ProjectHelper2.AntHandler: The common superclass for all SAX event handlers used to parse the configuration file.
ProjectHelper2.ElementHandler: Handler for all project elements (tasks, data types)
ProjectHelper2.MainHandler: The main handler - it handles the <project> tag.
ProjectHelper2.ProjectHandler: Handler for the top level "project" element.
ProjectHelper2.RootHandler: Handler for ant processing.
ProjectHelper2.TargetHandler: Handler for "target" and "extension-point" elements.
ProjectHelperImpl: Original helper.
ProjectHelperRepository: Repository of `ProjectHelper` found in the classpath or via some System properties.
ProjectHelperTask: Task to install project helper into Ant's runtime
PropertiesfileCache: Use java.util.Properties for storing the values.
Property: Sets a property by name, or set of properties (from file or resource) in the project.
PropertyExpander: Responsible for locating a property reference inside a String.
PropertyFile: Modifies settings in a property file.
PropertyFile.Entry: Instance of this class represents nested elements of a task propertyfile.
PropertyFile.Entry.Operation: Enumerated attribute with the values "+", "-", "="
PropertyFile.Entry.Type: Enumerated attribute with the values "int", "date" and "string".
PropertyFile.Unit: Borrowed from Tstamp
PropertyFileInputHandler: Reads input from a property file, the file name is read from the system property ant.input.properties, the prompt is the key for input.
PropertyHelper: Deals with properties - substitution, dynamic properties, etc.
PropertyHelper.Delegate: Marker interface for a PropertyHelper delegate.
PropertyHelper.PropertyEnumerator: Obtains the names of all known properties.
PropertyHelper.PropertyEvaluator: Looks up a property's value based on its name.
PropertyHelper.PropertySetter: Sets or overrides a property.
PropertyHelperTask: This task is designed to allow the user to install a different PropertyHelper on the current Project.
PropertyOutputStream: `OutputStream` that writes an Ant property.
PropertyResource: Exposes an Ant property as a Resource.
PropertySet: A set of properties.
PropertySet.BuiltinPropertySetName: Used for propertyref's builtin attribute.
PropertySet.PropertyRef: This is a nested class containing a reference to some properties and optionally a source of properties.
Provider: ANT Jar-Task SPI extension This class corresponds to the nested element <provider type="type"> in the <service type=""> nested element of the jar task.
ProxyDiagnostics: This class exists to create a string that tells diagnostics about the current state of proxy diagnostics.
ProxySetup: Code to do proxy setup.
PumpStreamHandler: Copies standard output and error of subprocesses to standard output and error of the parent process.
PumpStreamHandler.ThreadWithPumper: Specialized subclass that allows access to the running StreamPumper.
Pvcs: Extracts the latest edition of the source code from a PVCS repository.
PvcsProject: represents a project within the PVCS repository to extract files from.
Quantifier: EnumeratedAttribute for quantifier comparisons.
ReadableSelector: A selector that selects readable files.
ReaderInputStream: Adapts a `Reader` as an `InputStream`.
Recorder: Adds a listener to the current build process that records the output to a file.
Recorder.ActionChoices: A list of possible values for the `setAction()` method.
Recorder.VerbosityLevelChoices: A list of possible values for the `setLoglevel()` method.
RecorderEntry: This is a class that represents a recorder.
Rectangle
Rectangle
Redirector: The Redirector class manages the setup and connection of input and output redirection for an Ant project component.
RedirectorElement: Element representation of a `Redirector`.
Reference: Class to hold a reference to another object in the project.
ReflectUtil: Utility class to handle reflection on java objects.
ReflectWrapper: Utility class to handle reflection on java objects.
Regexp: Interface which represents a regular expression, and the operations that can be performed on it.
RegexpFactory: Regular expression factory, which will create Regexp objects.
RegexpMatcher: Interface describing a regular expression matcher.
RegexpMatcherFactory: Simple Factory Class that produces an implementation of RegexpMatcher based on the system property `ant.regexp.regexpimpl` and the classes available.
RegexpPatternMapper: Implementation of FileNameMapper that does regular expression replacements.
RegexpUtil: Regular expression utilities class which handles flag operations.
RegularExpression: A regular expression datatype.
Rename: Deprecated. The rename task is deprecated since Ant 1.2.
RenameExtensions: Deprecated. since 1.5.x.
Replace: Replaces all occurrences of one or more string tokens with given values in the indicated files.
ReplaceRegExp: Performs regular expression string replacements in a text file.
ReplaceTokens: Replaces tokens in the original input with user-supplied values.
ReplaceTokens.Token: Holds a token
ResolvePropertyMap: Class to resolve properties in a map.
Resource: Describes a "File-like" resource (File, ZipEntry, etc.).
ResourceCollection: Interface describing a collection of Resources.
ResourceComparator: Abstract Resource Comparator.
ResourceContains: <resourcecontains> Is a string contained in a resource (file currently)?
ResourceCount: Count resources from a ResourceCollection, storing to a property or writing to the log.
ResourceDecorator: Abstract class that delegates all reading methods of Resource to its wrapped resource and deals with reference handling.
ResourceExists: Condition that checks whether a given resource exists.
ResourceFactory: this interface should be implemented by classes (Scanners) needing to deliver information about resources.
ResourceList: Reads a resource as text document and creates a resource for each line.
ResourceLocation: Helper class to handle the `<dtd>` and `<entity>` nested elements.
Resources: Generic `ResourceCollection`: Either stores nested `ResourceCollection`s, making no attempt to remove duplicates, or references another `ResourceCollection`.
ResourceSelector: Interface for a Resource selector.
ResourceSelectorContainer: ResourceSelector container.
ResourcesMatch: Compares resources for equality based on size and content.
ResourceUtils: This class provides utility methods to process Resources.
ResourceUtils.ReadOnlyTargetFileException
ResourceUtils.ResourceSelectorProvider
Restrict: ResourceCollection that allows a number of selectors to be applied to a single ResourceCollection for the purposes of restricting or narrowing results.
Retry: Retries the nested task a set number of times
Retryable: Simple interface for executing a piece of code.
RetryHandler: A simple utility class to take a piece of code (that implements `Retryable` interface) and executes that with possibility to retry the execution in case of IOException.
Reverse: Reverses another ResourceComparator.
RExecTask: Automates the rexec protocol.
Rmic: Runs the rmic compiler against classes.
RmicAdapter: The interface that all rmic adapters must adhere to.
RmicAdapterFactory: Creates the necessary rmic adapter, given basic criteria.
Rotate: ImageOperation to rotate an image by a certain degree
Rotate: ImageOperation to rotate an image by a certain degree
Rpm: Invokes the rpm tool to build a Linux installation file.
RuntimeConfigurable: Wrapper class that holds the attributes of an element, its children, and any text within it.
Scale
Scale
Scale.ProportionsAttribute: Enumerated class for proportions attribute.
Scale.ProportionsAttribute: Enumerated class for proportions attribute.
SchemaValidate: Validate XML Schema documents.
SchemaValidate.SchemaLocation: representation of a schema location.
Scp: Ant task for sending files to remote machine over ssh/scp.
ScpFromMessage: A helper object representing an scp download.
ScpFromMessageBySftp: A helper object representing an scp download.
ScpToMessage: Utility class to carry out an upload scp transfer.
ScpToMessageBySftp: Utility class to carry out an upload by sftp.
Script: Executes a script.
ScriptCommandLauncher: A command launcher that uses an auxiliary script to launch commands in directories other than the current working directory.
ScriptCondition: A condition that lets you include script.
ScriptDef: Defines a task using a script.
ScriptDef.Attribute: Class representing an attribute definition
ScriptDef.NestedElement: Class to represent a nested element definition
ScriptDefBase: The script execution class.
ScriptFilter: Most of this is CAP (Cut And Paste) from the Script task ScriptFilter class, implements TokenFilter.Filter for scripts to use.
ScriptFixBSFPath: A class to modify a classloader to support BSF language support.
ScriptManager: Script manager `enum`.
ScriptMapper: Script support at map time.
ScriptRunner: This class is used to run BSF scripts
ScriptRunner: Deprecated. Implementation moved to another location.
ScriptRunnerBase: This is a common abstract base case for script runners.
ScriptRunnerCreator: This is a helper class used by ScriptRunnerHelper to create a ScriptRunner based on a classloader and on a language.
ScriptRunnerHelper: A class to help in creating, setting and getting script runners.
ScriptSelector: Selector that lets you run a script with selection logic inline
SecureInputHandler: Prompts and requests input.
SecurityManagerUtil
SelectorContainer: This is the interface for selectors that can contain other selectors.
SelectorScanner: An interface used to describe the actions required by any type of directory scanner that supports Selectors.
SelectorUtils: This is a utility class used by selectors and DirectoryScanner.
SelectSelector: This selector just holds one other selector and forwards all requests to it.
SendEmail: A task to send SMTP email.
Sequential: Sequential is a container task - it can contain other Ant tasks.
ServerDeploy: Controls hot deployment tools for J2EE servers.
Service: ANT Jar-Task SPI extension
SetPermissions: Sets `PosixFilePermission`s for resources.
SetPermissions.NonPosixMode: Options for dealing with file systems that don't support POSIX permissions.
SetProxy: Sets Java's web proxy properties, so that tasks and code run in the same JVM can have through-the-firewall access to remote web sites, and remote ftp sites.
SignedSelector: Selector that chooses files based on whether they are signed or not.
SignJar: Signs JAR or ZIP files with the javasign command line tool.
SilentLogger: A logger which logs nothing but build failure and what task might output
SimpleBigProjectLogger: Displays subproject names like `BigProjectLogger` but is otherwise as quiet as `NoBannerLogger`.
SingleCheckExecutor: "Single-check" Target executor implementation.
SingleTestClass: Represents the single `test` (class) that's configured to be launched by the `JUnitLauncherTask`
Size: Compares Resources by size.
Size: Size ResourceSelector.
SizeLimitCollection: ResourceCollection that imposes a size limit on another ResourceCollection.
SizeSelector: Selector that filters files based on their size.
SizeSelector.ByteUnits: Enumerated attribute with the values for units.
SizeSelector.SizeComparisons: Enumerated attribute with the values for size comparison.
Sj: The implementation of the sj compiler.
Sleep: Sleep, or pause, for a period of time.
SmtpResponseReader: A wrapper around the raw input from the SMTP server that assembles multi line responses into a single String.
Socket: Condition to wait for a TCP/IP socket to have a listener.
Sort: ResourceCollection that sorts another ResourceCollection.
SortFilter: Sort a file before and/or after the file.
SOS: A base class for creating tasks for executing commands on SourceOffSite.
SOSCheckin: Commits and unlocks files in Visual SourceSafe via a SourceOffSite server.
SOSCheckout: Retrieves and locks files in Visual SourceSafe via a SourceOffSite server.
SOSCmd: Interface to hold constants used by the SOS tasks
SOSGet: Retrieves a read-only copy of the specified project or file from Visual SourceSafe via a SourceOffSite server.
SOSLabel: Labels Visual SourceSafe files via a SourceOffSite server.
SoundTask: Plays a sound file at the end of the build, according to whether the build failed or succeeded.
SourceFileScanner: Utility class that collects the functionality of the various scanDir methods that have been scattered in several tasks before.
Specification: Utility class that represents either an available "Optional Package" (formerly known as "Standard Extension") as described in the manifest of a JAR file, or the requirement for such an optional package.
SplashTask: Creates a splash screen.
SplitClassLoader: Specialized classloader for tasks that need finer grained control over which classes are to be loaded via Ant's classloader and which should not even if they are available.
SQLExec: Executes a series of SQL statements on a database using JDBC.
SQLExec.DelimiterType: delimiters we support, "normal" and "row"
SQLExec.OnError: The action a task should perform on an error, one of "continue", "stop" and "abort"
SSHBase: Base class for Ant tasks using jsch.
SSHExec: Executes a command on a remote machine via ssh.
SSHSession: Establishes an ssh session with a remote machine, optionally establishing port forwarding, then executes any nested task(s) before closing the session.
SSHSession.NestedSequential: The class corresponding to the sequential nested element.
SSHUserInfo: Class containing information on an SSH user.
StandaloneLauncher: Used for launching forked tests from the `JUnitLauncherTask`.
StreamPumper: Copies all data from an input stream to an output stream.
StreamUtils
StringCPInfo: A String Constant Pool Entry.
StringInputStream: Wraps a String as an InputStream.
StringResource: Exposes a string as a Resource.
StringTokenizer: Class to tokenize the input as areas separated by white space, or by a specified list of delim characters.
StringUtils: A set of helper methods related to string manipulation.
StripJavaComments: This is a Java comment and string stripper reader that filters those lexical tokens out for purposes of simple Java parsing.
StripLineBreaks: Filter to flatten the stream to a single line.
StripLineComments: This filter strips line comments.
StripLineComments.Comment: The class that holds a comment representation.
SubAnt: Calls a given target for all defined sub-builds.
SubBuildListener: Instances of classes that implement this interface can register to be also notified when things happened during a subbuild.
Substitution: A regular expression substitution datatype.
SuffixLines: Attaches a suffix to every line.
SummaryJUnitResultFormatter: Prints short summary output of the test to Ant's logging system.
SunJavah: Adapter to com.sun.tools.javah.oldjavah.Main or com.sun.tools.javah.Main.
SunNative2Ascii: Adapter to sun.tools.native2ascii.Main.
SunRmic: The implementation of the rmic for SUN's JDK.
SymbolicLinkUtils: Deprecated. Starting Ant 1.10.2, this class is now deprecated in favour of the Java `Files` APIs introduced in Java 7, for dealing with symbolic links
Symlink: Creates, Deletes, Records and Restores Symlinks.
SymlinkSelector: A selector that selects symbolic links.
Sync: Synchronize a local target directory from the files defined in one or more filesets.
Sync.MyCopy: Subclass Copy in order to access it's file/dir maps.
Sync.SyncTarget: Inner class used to hold exclude patterns and selectors to save stuff that happens to live in the target directory but should not get removed.
TabsToSpaces: Converts tabs to spaces.
TailFilter: Reads the last `n` lines of a stream.
Tar: Creates a tar archive.
Tar.TarCompressionMethod: Valid Modes for Compression attribute to Tar Task
Tar.TarFileSet: This is a FileSet with the option to specify permissions and other attributes.
Tar.TarLongFileMode: Set of options for long file handling in the task.
TarArchiveSparseEntry: This class represents a sparse entry in a Tar archive.
TarBuffer: The TarBuffer class implements the tar archive concept of a buffered input stream.
TarConstants: This interface contains all the definitions used in the package.
TarEntry: This class represents an entry in a Tar archive.
TarFileSet: A TarFileSet is a FileSet with extra attributes useful in the context of Tar/Jar tasks.
Target: Class to implement a target object with required parameters.
TarInputStream: The TarInputStream reads a UNIX tar archive as an InputStream.
TarOutputStream: The TarOutputStream writes a UNIX tar archive as an OutputStream.
TarResource: A Resource representation of an entry in a tar archive.
TarScanner: Scans tar archives for resources.
TarUtils: This class provides static utility methods to work with byte streams.
Task: Base class for all tasks.
TaskAdapter: Uses introspection to "adapt" an arbitrary Bean which doesn't itself extend Task, but still contains an execute method and optionally a setProject method.
TaskConfigurationChecker: Helper class for the check of the configuration of a given task.
TaskContainer: Interface for objects which can contain tasks.
Taskdef: Adds a task definition to the current project, such that this new task can be used in the current project.
TaskLogger: A facade that makes logging nicer to use.
TaskOutputStream: Deprecated. since 1.2.x.
TearDownOnVmCrash: Formatter that doesn't create any output but tries to invoke the tearDown method on a testcase if that test was forked and caused a timeout or VM crash.
TeeOutputStream: A simple T-piece to replicate an output stream into two separate streams
TelnetTask: Automates the telnet protocol.
TempFile: This task sets a property to the name of a temporary file.
TestClasses: Represents a `testclasses` that's configured to be launched by the `JUnitLauncherTask`
TestDefinition: Represents the configuration details of a test that needs to be launched by the `JUnitLauncherTask`
TestDefinition.ForkedRepresentation
TestExecutionContext: A `TestExecutionContext` represents the execution context for a test that has been launched by the `JUnitLauncherTask` and provides any necessary contextual information about such tests.
TestIgnored
TestListenerWrapper
TestResultFormatter: A `TestExecutionListener` which lets implementing classes format and write out the test execution results.
Text
Text
TimeComparison: EnumeratedAttribute for time comparisons.
TimeoutObserver: Interface for classes that want to be notified by Watchdog.
TimestampedLogger: Like a normal logger, except with timed outputs
TokenFilter: This splits up input into tokens and passes the tokens to a sequence of filters.
TokenFilter.ChainableReaderFilter: Abstract class that converts derived filter classes into ChainableReaderFilter's
TokenFilter.ContainsRegex: filter to filter tokens matching regular expressions.
TokenFilter.ContainsString: Simple filter to filter lines contains strings
TokenFilter.DeleteCharacters: Filter to delete characters
TokenFilter.FileTokenizer: class to read the complete input into a string
TokenFilter.Filter: string filters implement this interface
TokenFilter.IgnoreBlank: Filter remove empty tokens
TokenFilter.ReplaceRegex: filter to replace regex.
TokenFilter.ReplaceString: Simple replace string filter.
TokenFilter.StringTokenizer: class to tokenize the input as areas separated by white space, or by a specified list of delim characters.
TokenFilter.Trim: Filter to trim white space
TokenizedPath: Container for a path that has been split into its components.
TokenizedPattern: Provides reusable path pattern matching.
Tokenizer: input stream tokenizers implement this interface
Tokens: ResourceCollection consisting of StringResources gathered from tokenizing another ResourceCollection with a Tokenizer implementation.
Touch: Touch a file and/or fileset(s) and/or filelist(s); corresponds to the Unix touch command.
Touch.DateFormatFactory
Touchable: Interface to be implemented by "touchable" resources; that is, those whose modification time can be altered.
Transform: Has been merged into ExecuteOn, empty class for backwards compatibility.
TransformOperation
TransformOperation
Translate: Translates text embedded in files using Resource Bundle files.
TraXLiaison: Concrete liaison for XSLT processor implementing TraX.
Truncate: Set the length of one or more files, as the intermittently available `truncate` Unix utility/function.
Tstamp: Sets properties to the current time, or offsets from the current time.
Tstamp.Unit: set of valid units to use for time offsets.
Type: Compares Resources by is-directory status.
Type: Type file/dir ResourceSelector.
Type.FileDir: Implements the type attribute.
TypeAdapter: Used to wrap types.
Typedef: Adds a data type definition to the current project.
TypeFound: looks for a task or other Ant type that exists.
TypeSelector: Selector that selects a certain kind of file: directory or regular.
TypeSelector.FileType: Enumerated attribute with the values for types of file
UnicodeCommentExtraField: Info-ZIP Unicode Comment Extra Field (0x6375):
UnicodePathExtraField: Info-ZIP Unicode Path Extra Field (0x7075):
UnicodeUtil: Contains one helper method to create a backslash u escape
Union: ResourceCollection representing the union of multiple nested ResourceCollections.
UniqFilter: Like the Unix uniq(1) command, only returns tokens that are different from their ancestor token.
UnixStat: Constants from stat.h on Unix systems.
UnknownElement: Wrapper class that holds all the information necessary to create a task or data type that did not exist when Ant started, or one which has had its definition updated to use a different implementation class.
Unpack: Abstract Base class for unpack tasks.
UnPackageNameMapper: Maps dotted package name matches to a directory name.
UnparseableExtraFieldData: Wrapper for extra field data that doesn't conform to the recommended format of header-tag + size + data.
UnrecognizedExtraField: Simple placeholder for all those extra fields we don't want to deal with.
UnsupportedAttributeException: Used to report attempts to set an unsupported attribute
UnsupportedElementException: Used to report attempts to set an unsupported element When the attempt to set the element is made, the code does not not know the name of the task/type based on a mapping from the classname to the task/type.
UnsupportedZipFeatureException: Exception thrown when attempting to read or write data for a zip entry that uses ZIP features not supported by this library.
UnsupportedZipFeatureException.Feature: ZIP Features that may or may not be supported.
Untar: Untar a file.
Untar.UntarCompressionMethod: Valid Modes for Compression attribute to Untar Task
Unxz: Expands a file that has been compressed with the XZ algorithm.
UpToDate: Sets the given property if the specified target has a timestamp greater than all of the source files.
URLProvider: This is an interface that resources that can provide an URL should implement.
URLResolver: Resolver that just returns s specified location.
URLResource: Exposes a URL as a Resource.
Utf8CPInfo: A UTF8 Constant Pool Entry.
UUEncoder: UUEncoding of an input stream placed into an OutputStream.
VectorSet<E>: Subclass of Vector that won't store duplicate entries and shows HashSet's constant time performance characteristics for the contains method.
VerifyJar: JAR verification task.
VmsCommandLauncher: A command launcher for VMS that writes the command to a temporary DCL script before launching commands.
WaitFor: Wait for an external event to occur.
WaitFor.Unit: The enumeration of units: millisecond, second, minute, hour, day, week
War: An extension of <jar> to create a WAR archive.
Watchdog: Generalization of `ExecuteWatchdog`
WeakishReference: Deprecated. deprecated 1.7; will be removed in Ant1.8 Just use `WeakReference` directly.
WeakishReference.HardReference: Deprecated. since 1.7.
WeakishReference12: Deprecated. since 1.7.
WeblogicDeploymentTool: The weblogic element is used to control the weblogic.ejbc compiler for generating WebLogic EJB jars.
WebLogicHotDeploymentTool: An Ant wrapper task for the weblogic.deploy tool.
WeblogicTOPLinkDeploymentTool: Deployment tool for WebLogic TOPLink.
WebsphereDeploymentTool: WebSphere deployment tool that augments the ejbjar task.
WhichResource: Find a class or resource on the supplied classpath, or the system classpath if none is supplied.
WindowsJunctionSelector: A selector that selects Windows junctions.
WindowsJunctionUtils: Contains methods related to Windows NTFS junctions.
WinNTCommandLauncher: A command launcher for Windows XP/2000/NT that uses 'cmd.exe' when launching commands in directories other than the current working directory.
WLJspc: Precompiles JSP's using WebLogic's JSP compiler (weblogic.jspc).
WLRmic: The implementation of the rmic for WebLogic
WorkerAnt: A worker ant executes a single task in a background thread.
WritableSelector: A selector that selects writable files.
Xalan2TraceSupport: Sets up trace support for a given transformer.
XMLCatalog: This data type provides a catalog of resource locations (such as DTDs and XML entities), based on the OASIS "Open Catalog" standard.
XmlConstants: XML Parser constants, all kept in one place for ease of reuse
XMLConstants: Interface groups XML constants.
XMLFragment: Use this class as a nested element if you want to get a literal DOM fragment of something nested into your task/type.
XMLJUnitResultFormatter: Prints XML output of the test to a specified Writer.
XmlLogger: Generates a file in the current directory with an XML description of what happened during a build.
XmlProperty: Loads property values from a valid XML file, generating the property names from the file's element and attribute names.
XMLResultAggregator: Aggregates all <junit> XML formatter testsuite data under a specific directory and transforms the results via XSLT.
XMLValidateTask: Checks XML files are valid (or only well formed).
XMLValidateTask.Attribute: The class to create to set a feature of the parser.
XMLValidateTask.Property: A Parser property.
XNewRmic: Run rmic in a new process with -Xnew set.
Xor: The `Xor` condition type to exclusive or operations.
XSLTLiaison: Proxy interface for XSLT processors.
XSLTLiaison2: Extended Proxy interface for XSLT processors.
XSLTLiaison3: Extends Proxy interface for XSLT processors.
XSLTLiaison4: Extends Proxy interface for XSLT processors: adds support for XSLT parameters of various types (not only String)
XSLTLogger: Interface to log messages for XSLT
XSLTLoggerAware: Interface for a class that one can set an XSLTLogger on.
XSLTProcess: Processes a set of XML documents via XSLT.
XSLTProcess.Factory: The factory element to configure a transformer factory
XSLTProcess.Factory.Attribute: A JAXP factory attribute.
XSLTProcess.Factory.Feature: A feature for the TraX factory.
XSLTProcess.OutputProperty: Specify how the result tree should be output as specified in the specification.
XSLTProcess.Param: The Param inner class used to store XSL parameters
XSLTProcess.ParamType: Enum for types of the parameter expression.
XSLTTraceSupport: Sets up trace support for a given transformer.
Xz: Compresses a file with the XZ algorithm.
XzResource: A XZ compressed resource.
Zip: Create a Zip file.
Zip.ArchiveState: Holds the up-to-date status and the out-of-date resources of the original archive.
Zip.Duplicate: Possible behaviors when a duplicate file is added: "add", "preserve" or "fail"
Zip.UnicodeExtraField: Policy for creation of Unicode extra fields: never, always or not-encodeable.
Zip.WhenEmpty: Possible behaviors when there are no matching files for the task: "fail", "skip", or "create".
Zip.Zip64ModeAttribute: The choices for Zip64 extensions.
Zip64ExtendedInformationExtraField: Holds size and other extended information for entries that use Zip64 features.
Zip64Mode: The different modes `ZipOutputStream` can operate in.
Zip64RequiredException: Exception thrown when attempting to write data that requires Zip64 support to an archive and `UseZip64` has been set to `Never`.
ZipEightByteInteger: Utility class that represents an eight byte integer with conversion rules for the big endian byte order of ZIP files.
ZipEncoding: An interface for encoders that do a pretty encoding of ZIP filenames.
ZipEncodingHelper: Static helper functions for robustly encoding filenames in zip files.
ZipEntry: Extension that adds better handling of extra fields and provides access to the internal and external file attributes.
ZipExtraField: General format of extra field data.
ZipFile: Replacement for `java.util.ZipFile`.
ZipFileSet: A ZipFileSet is a FileSet with extra attributes useful in the context of Zip/Jar tasks.
ZipLong: Utility class that represents a four byte integer with conversion rules for the big endian byte order of ZIP files.
ZipOutputStream: Reimplementation of `java.util.zip.ZipOutputStream` that does handle the extended functionality of this package, especially internal/external file attributes and extra fields with different layouts for local file data and central directory entries.
ZipOutputStream.UnicodeExtraFieldPolicy: enum that represents the possible policies for creating Unicode extra fields.
ZipResource: A Resource representation of an entry in a zipfile.
ZipScanner: Scans zip archives for resources.
ZipShort: Utility class that represents a two byte integer with conversion rules for the big endian byte order of ZIP files.
ZipUtil: Utility class for handling DOS and Java time conversions.