Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache Ant Source Code Files
Apache Ant Source Code Files are inside the Apache Ant source package file like apache-ant-1.10.10-src.zip. Unzip the source package file and go to the "src/main" sub-directory, you will see source code files.
Here is the list of Java source code files of the Apache Ant 1.10.10 in \Users\fyicenter\apache-ant-1.10.10\src\main:
✍: FYIcenter.com
⏎ org/apache/tools/ant/taskdefs/Concat.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package org.apache.tools.ant.taskdefs; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.Reader; import java.io.StringReader; import java.io.Writer; import java.nio.file.Files; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; import java.util.Vector; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.Project; import org.apache.tools.ant.ProjectComponent; import org.apache.tools.ant.Task; import org.apache.tools.ant.filters.util.ChainReaderHelper; import org.apache.tools.ant.types.FileList; import org.apache.tools.ant.types.FileSet; import org.apache.tools.ant.types.FilterChain; import org.apache.tools.ant.types.Path; import org.apache.tools.ant.types.Resource; import org.apache.tools.ant.types.ResourceCollection; import org.apache.tools.ant.types.resources.FileResource; import org.apache.tools.ant.types.resources.Intersect; import org.apache.tools.ant.types.resources.LogOutputResource; import org.apache.tools.ant.types.resources.Resources; import org.apache.tools.ant.types.resources.Restrict; import org.apache.tools.ant.types.resources.StringResource; import org.apache.tools.ant.types.resources.selectors.Exists; import org.apache.tools.ant.types.resources.selectors.Not; import org.apache.tools.ant.types.resources.selectors.ResourceSelector; import org.apache.tools.ant.types.selectors.SelectorUtils; import org.apache.tools.ant.util.ConcatResourceInputStream; import org.apache.tools.ant.util.FileUtils; import org.apache.tools.ant.util.ReaderInputStream; import org.apache.tools.ant.util.ResourceUtils; /** * This class contains the 'concat' task, used to concatenate a series * of files into a single stream. The destination of this stream may * be the system console, or a file. The following is a sample * invocation: * * <pre> * <concat destfile="${build.dir}/index.xml" * append="false"> * * <fileset dir="${xml.root.dir}" * includes="*.xml" /> * * </concat> * </pre> * */ public class Concat extends Task implements ResourceCollection { // The size of buffers to be used private static final int BUFFER_SIZE = 8192; private static final FileUtils FILE_UTILS = FileUtils.getFileUtils(); private static final ResourceSelector EXISTS = new Exists(); private static final ResourceSelector NOT_EXISTS = new Not(EXISTS); /** * sub element points to a file or contains text */ public static class TextElement extends ProjectComponent { private String value = ""; private boolean trimLeading = false; private boolean trim = false; private boolean filtering = true; private String encoding = null; /** * whether to filter the text in this element * or not. * * @param filtering true if the text should be filtered. * the default value is true. */ public void setFiltering(boolean filtering) { this.filtering = filtering; } /** return the filtering attribute */ private boolean getFiltering() { return filtering; } /** * The encoding of the text element * * @param encoding the name of the charset used to encode */ public void setEncoding(String encoding) { this.encoding = encoding; } /** * set the text using a file * @param file the file to use * @throws BuildException if the file does not exist, or cannot be * read */ public void setFile(File file) throws BuildException { // non-existing files are not allowed if (!file.exists()) { throw new BuildException("File %s does not exist.", file); } BufferedReader reader = null; try { if (this.encoding == null) { reader = new BufferedReader(new FileReader(file)); } else { reader = new BufferedReader( new InputStreamReader(Files.newInputStream(file.toPath()), this.encoding)); } value = FileUtils.safeReadFully(reader); } catch (IOException ex) { throw new BuildException(ex); } finally { FileUtils.close(reader); } } /** * set the text using inline * @param value the text to place inline */ public void addText(String value) { this.value += getProject().replaceProperties(value); } /** * s:^\s*:: on each line of input * @param strip if true do the trim */ public void setTrimLeading(boolean strip) { this.trimLeading = strip; } /** * whether to call text.trim() * @param trim if true trim the text */ public void setTrim(boolean trim) { this.trim = trim; } /** * @return the text, after possible trimming */ public String getValue() { if (value == null) { value = ""; } if (value.trim().isEmpty()) { value = ""; } if (trimLeading) { StringBuilder b = new StringBuilder(); boolean startOfLine = true; for (final char ch : value.toCharArray()) { if (startOfLine) { if (ch == ' ' || ch == '\t') { continue; } startOfLine = false; } b.append(ch); if (ch == '\n' || ch == '\r') { startOfLine = true; } } value = b.toString(); } if (trim) { value = value.trim(); } return value; } } private interface ReaderFactory<S> { Reader getReader(S s) throws IOException; } /** * This class reads a Reader and ensures it ends with the desired linebreak * @since Ant 1.10.10 */ private final class LastLineFixingReader extends Reader { private final Reader reader; private int lastPos = 0; private final char[] lastChars = new char[eolString.length()]; private boolean needAddSeparator = false; private LastLineFixingReader(Reader reader) { this.reader = reader; } /** * Read a character from the current reader object. Advance * to the next if the reader is finished. * @return the character read, -1 for EOF on the last reader. * @exception IOException - possibly thrown by the read for a reader * object. */ @Override public int read() throws IOException { if (needAddSeparator) { if (lastPos >= eolString.length()) { return -1; } else { return eolString.charAt(lastPos++); } } int ch = reader.read(); if (ch == -1) { if (isMissingEndOfLine()) { needAddSeparator = true; lastPos = 1; return eolString.charAt(0); } } else { addLastChar((char) ch); return ch; } return -1; } /** * Read into the buffer <code>cbuf</code>. * @param cbuf The array to be read into. * @param off The offset. * @param len The length to read. * @exception IOException - possibly thrown by the reads to the * reader objects. */ @Override public int read(char[] cbuf, int off, int len) throws IOException { int amountRead = 0; while (true) { if (needAddSeparator) { if (lastPos >= eolString.length()) { break; } cbuf[off] = eolString.charAt(lastPos++); len--; off++; amountRead++; if (len == 0) { return amountRead; } continue; } int nRead = reader.read(cbuf, off, len); if (nRead == -1 || nRead == 0) { if (isMissingEndOfLine()) { needAddSeparator = true; lastPos = 0; } else { break; } } else { for (int i = nRead; i > (nRead - lastChars.length); --i) { if (i <= 0) { break; } addLastChar(cbuf[off + i - 1]); } len -= nRead; off += nRead; amountRead += nRead; if (len == 0) { return amountRead; } } } if (amountRead == 0) { return -1; } return amountRead; } /** * Close the current reader */ @Override public void close() throws IOException { reader.close(); } /** * if checking for end of line at end of file * add a character to the lastchars buffer */ private void addLastChar(char ch) { System.arraycopy(lastChars, 1, lastChars, 0, lastChars.length - 2 + 1); lastChars[lastChars.length - 1] = ch; } /** * return true if the lastchars buffer does * not contain the line separator */ private boolean isMissingEndOfLine() { for (int i = 0; i < lastChars.length; ++i) { if (lastChars[i] != eolString.charAt(i)) { return true; } } return false; } } /** * This class reads from each of the source files in turn. * The concatenated result can then be filtered as * a single stream. */ private final class MultiReader<S> extends Reader { private Reader reader = null; private Iterator<S> readerSources; private ReaderFactory<S> factory; private final boolean filterBeforeConcat; private MultiReader(Iterator<S> readerSources, ReaderFactory<S> factory, boolean filterBeforeConcat) { this.readerSources = readerSources; this.factory = factory; this.filterBeforeConcat = filterBeforeConcat; } private Reader getReader() throws IOException { if (reader == null && readerSources.hasNext()) { reader = factory.getReader(readerSources.next()); if (isFixLastLine()) { reader = new LastLineFixingReader(reader); } if (filterBeforeConcat) { reader = getFilteredReader(reader); } } return reader; } private void nextReader() throws IOException { close(); reader = null; } /** * Read a character from the current reader object. Advance * to the next if the reader is finished. * @return the character read, -1 for EOF on the last reader. * @exception IOException - possibly thrown by the read for a reader * object. */ @Override public int read() throws IOException { while (getReader() != null) { int ch = getReader().read(); if (ch == -1) { nextReader(); } else { return ch; } } return -1; } /** * Read into the buffer <code>cbuf</code>. * @param cbuf The array to be read into. * @param off The offset. * @param len The length to read. * @exception IOException - possibly thrown by the reads to the * reader objects. */ @Override public int read(char[] cbuf, int off, int len) throws IOException { int amountRead = 0; while (getReader() != null) { int nRead = getReader().read(cbuf, off, len); if (nRead == -1 || nRead == 0) { nextReader(); } else { len -= nRead; off += nRead; amountRead += nRead; if (len == 0) { return amountRead; } } } if (amountRead == 0) { return -1; } return amountRead; } /** * Close the current reader */ @Override public void close() throws IOException { if (reader != null) { reader.close(); } } private boolean isFixLastLine() { return fixLastLine && textBuffer == null; } } private final class ConcatResource extends Resource { private ResourceCollection c; private ConcatResource(ResourceCollection c) { this.c = c; } @Override public InputStream getInputStream() { if (binary) { ConcatResourceInputStream result = new ConcatResourceInputStream(c); result.setManagingComponent(this); return result; } Reader resourceReader; if (filterBeforeConcat) { resourceReader = new MultiReader<>(c.iterator(), resourceReaderFactory, true); } else { resourceReader = getFilteredReader( new MultiReader<>(c.iterator(), resourceReaderFactory, false)); } Reader rdr; if (header == null && footer == null) { rdr = resourceReader; } else { int readerCount = 1; if (header != null) { readerCount++; } if (footer != null) { readerCount++; } Reader[] readers = new Reader[readerCount]; int pos = 0; if (header != null) { readers[pos] = new StringReader(header.getValue()); if (header.getFiltering()) { readers[pos] = getFilteredReader(readers[pos]); } pos++; } readers[pos++] = resourceReader; if (footer != null) { readers[pos] = new StringReader(footer.getValue()); if (footer.getFiltering()) { readers[pos] = getFilteredReader(readers[pos]); } } rdr = new MultiReader<>(Arrays.asList(readers).iterator(), identityReaderFactory, false); } return outputEncoding == null ? new ReaderInputStream(rdr) : new ReaderInputStream(rdr, outputEncoding); } @Override public String getName() { return resourceName == null ? "concat (" + String.valueOf(c) + ")" : resourceName; } } // Attributes. /** * The destination of the stream. If <code>null</code>, the system * console is used. */ private Resource dest; /** * Whether or not the stream should be appended if the destination file * exists. * Defaults to <code>false</code>. */ private boolean append; /** * Stores the input file encoding. */ private String encoding; /** Stores the output file encoding. */ private String outputEncoding; /** Stores the binary attribute */ private boolean binary; /** Stores the filterBeforeConcat attribute */ private boolean filterBeforeConcat; // Child elements. /** * This buffer stores the text within the 'concat' element. */ private StringBuffer textBuffer; /** * Stores a collection of file sets and/or file lists, used to * select multiple files for concatenation. */ private Resources rc; /** for filtering the concatenated */ private Vector<FilterChain> filterChains; /** ignore dates on input files */ private boolean forceOverwrite = true; /** overwrite read-only files */ private boolean force = false; /** String to place at the start of the concatenated stream */ private TextElement footer; /** String to place at the end of the concatenated stream */ private TextElement header; /** add missing line.separator to files **/ private boolean fixLastLine = false; /** endofline for fixlast line */ private String eolString; /** outputwriter */ private Writer outputWriter = null; /** whether to not create dest if no source files are * available */ private boolean ignoreEmpty = true; /** exposed resource name */ private String resourceName; private ReaderFactory<Resource> resourceReaderFactory = new ReaderFactory<Resource>() { @Override public Reader getReader(Resource o) throws IOException { InputStream is = o.getInputStream(); return new BufferedReader(encoding == null ? new InputStreamReader(is) : new InputStreamReader(is, encoding)); } }; private ReaderFactory<Reader> identityReaderFactory = o -> o; /** * Construct a new Concat task. */ public Concat() { reset(); } /** * Reset state to default. */ public void reset() { append = false; forceOverwrite = true; dest = null; encoding = null; outputEncoding = null; fixLastLine = false; filterChains = null; footer = null; header = null; binary = false; outputWriter = null; textBuffer = null; eolString = System.lineSeparator(); rc = null; ignoreEmpty = true; force = false; } // Attribute setters. /** * Sets the destination file, or uses the console if not specified. * @param destinationFile the destination file */ public void setDestfile(File destinationFile) { setDest(new FileResource(destinationFile)); } /** * Set the resource to write to. * @param dest the Resource to write to. * @since Ant 1.8 */ public void setDest(Resource dest) { this.dest = dest; } /** * Sets the behavior when the destination exists. If set to * <code>true</code> the task will append the stream data an * {@link Appendable} resource; otherwise existing content will be * overwritten. Defaults to <code>false</code>. * @param append if true append output. */ public void setAppend(boolean append) { this.append = append; } /** * Sets the character encoding * @param encoding the encoding of the input stream and unless * outputencoding is set, the outputstream. */ public void setEncoding(String encoding) { this.encoding = encoding; if (outputEncoding == null) { outputEncoding = encoding; } } /** * Sets the character encoding for outputting * @param outputEncoding the encoding for the output file * @since Ant 1.6 */ public void setOutputEncoding(String outputEncoding) { this.outputEncoding = outputEncoding; } /** * Force overwrite existing destination file * @param forceOverwrite if true always overwrite, otherwise only * overwrite if the output file is older any of the * input files. * @since Ant 1.6 * @deprecated use #setOverwrite instead */ @Deprecated public void setForce(boolean forceOverwrite) { this.forceOverwrite = forceOverwrite; } /** * Force overwrite existing destination file * @param forceOverwrite if true always overwrite, otherwise only * overwrite if the output file is older any of the * input files. * @since Ant 1.8.2 */ public void setOverwrite(boolean forceOverwrite) { setForce(forceOverwrite); } /** * Whether read-only destinations will be overwritten. * * <p>Defaults to false</p> * * @param f boolean * @since Ant 1.8.2 */ public void setForceReadOnly(boolean f) { force = f; } /** * Sets the behavior when no source resource files are available. If set to * <code>false</code> the destination file will always be created. * Defaults to <code>true</code>. * @param ignoreEmpty if false, honour destination file creation. * @since Ant 1.8.0 */ public void setIgnoreEmpty(boolean ignoreEmpty) { this.ignoreEmpty = ignoreEmpty; } /** * Set the name that will be reported by the exposed {@link Resource}. * @param resourceName to set * @since Ant 1.8.3 */ public void setResourceName(String resourceName) { this.resourceName = resourceName; } // Nested element creators. /** * Path of files to concatenate. * @return the path used for concatenating * @since Ant 1.6 */ public Path createPath() { Path path = new Path(getProject()); add(path); return path; } /** * Set of files to concatenate. * @param set the set of files */ public void addFileset(FileSet set) { add(set); } /** * List of files to concatenate. * @param list the list of files */ public void addFilelist(FileList list) { add(list); } /** * Add an arbitrary ResourceCollection. * @param c the ResourceCollection to add. * @since Ant 1.7 */ public void add(ResourceCollection c) { synchronized (this) { if (rc == null) { rc = new Resources(); rc.setProject(getProject()); rc.setCache(true); } } rc.add(c); } /** * Adds a FilterChain. * @param filterChain a filterchain to filter the concatenated input * @since Ant 1.6 */ public void addFilterChain(FilterChain filterChain) { if (filterChains == null) { filterChains = new Vector<>(); } filterChains.addElement(filterChain); } /** * This method adds text which appears in the 'concat' element. * @param text the text to be concatenated. */ public void addText(String text) { if (textBuffer == null) { // Initialize to the size of the first text fragment, with // the hopes that it's the only one. textBuffer = new StringBuffer(text.length()); } // Append the fragment -- we defer property replacement until // later just in case we get a partial property in a fragment. textBuffer.append(text); } /** * Add a header to the concatenated output * @param headerToAdd the header * @since Ant 1.6 */ public void addHeader(TextElement headerToAdd) { this.header = headerToAdd; } /** * Add a footer to the concatenated output * @param footerToAdd the footer * @since Ant 1.6 */ public void addFooter(TextElement footerToAdd) { this.footer = footerToAdd; } /** * Append line.separator to files that do not end * with a line.separator, default false. * @param fixLastLine if true make sure each input file has * new line on the concatenated stream * @since Ant 1.6 */ public void setFixLastLine(boolean fixLastLine) { this.fixLastLine = fixLastLine; } /** * Specify the end of line to find and to add if * not present at end of each input file. This attribute * is used in conjunction with fixlastline. * @param crlf the type of new line to add - * cr, mac, lf, unix, crlf, or dos * @since Ant 1.6 */ public void setEol(FixCRLF.CrLf crlf) { String s = crlf.getValue(); if ("cr".equals(s) || "mac".equals(s)) { eolString = "\r"; } else if ("lf".equals(s) || "unix".equals(s)) { eolString = "\n"; } else if ("crlf".equals(s) || "dos".equals(s)) { eolString = "\r\n"; } } /** * Set the output writer. This is to allow * concat to be used as a nested element. * @param outputWriter the output writer. * @since Ant 1.6 */ public void setWriter(Writer outputWriter) { this.outputWriter = outputWriter; } /** * Set the binary attribute. If true, concat will concatenate the files * byte for byte. This mode does not allow any filtering or other * modifications to the input streams. The default value is false. * @since Ant 1.6.2 * @param binary if true, enable binary mode. */ public void setBinary(boolean binary) { this.binary = binary; } /** * Set the filterBeforeConcat attribute. If true, concat will filter each * input through the filterchain before concatenating the results. This * allows to e.g. use the FileTokenizer to tokenize each input. * @param filterBeforeConcat if true, filter each input before concatenation * @since Ant 1.10.10 */ public void setFilterBeforeConcat(final boolean filterBeforeConcat) { this.filterBeforeConcat = filterBeforeConcat; } /** * Execute the concat task. */ @Override public void execute() { validate(); if (binary && dest == null) { throw new BuildException( "dest|destfile attribute is required for binary concatenation"); } ResourceCollection c = getResources(); if (isUpToDate(c)) { log(dest + " is up-to-date.", Project.MSG_VERBOSE); return; } if (c.isEmpty() && ignoreEmpty) { return; } try { //most of these are defaulted because the concat-as-a-resource code hijacks a lot: ResourceUtils.copyResource(new ConcatResource(c), dest == null ? new LogOutputResource(this, Project.MSG_WARN) : dest, null, null, true, false, append, null, null, getProject(), force); } catch (IOException e) { throw new BuildException("error concatenating content to " + dest, e); } } /** * Implement ResourceCollection. * @return Iterator<Resource>. */ @Override public Iterator<Resource> iterator() { validate(); return Collections .<Resource> singletonList(new ConcatResource(getResources())) .iterator(); } /** * Implement ResourceCollection. * @return 1. */ @Override public int size() { return 1; } /** * Implement ResourceCollection. * @return false. */ @Override public boolean isFilesystemOnly() { return false; } /** * Validate configuration options. */ private void validate() { // treat empty nested text as no text sanitizeText(); // if binary check if incompatible attributes are used if (binary) { if (textBuffer != null) { throw new BuildException( "Nested text is incompatible with binary concatenation"); } if (encoding != null || outputEncoding != null) { throw new BuildException( "Setting input or output encoding is incompatible with binary concatenation"); } if (filterChains != null) { throw new BuildException( "Setting filters is incompatible with binary concatenation"); } if (fixLastLine) { throw new BuildException( "Setting fixlastline is incompatible with binary concatenation"); } if (header != null || footer != null) { throw new BuildException( "Nested header or footer is incompatible with binary concatenation"); } } if (dest != null && outputWriter != null) { throw new BuildException( "Cannot specify both a destination resource and an output writer"); } // Sanity check our inputs. if (rc == null && textBuffer == null) { // Nothing to concatenate! throw new BuildException( "At least one resource must be provided, or some text."); } if (rc != null && textBuffer != null) { // If using resources, disallow inline text. This is similar to // using GNU 'cat' with file arguments--stdin is simply ignored. throw new BuildException( "Cannot include inline text when using resources."); } } /** * Get the resources to concatenate. */ private ResourceCollection getResources() { if (rc == null) { return new StringResource(getProject(), textBuffer.toString()); } if (dest != null) { Intersect checkDestNotInSources = new Intersect(); checkDestNotInSources.setProject(getProject()); checkDestNotInSources.add(rc); checkDestNotInSources.add(dest); if (checkDestNotInSources.size() > 0) { throw new BuildException( "Destination resource %s was specified as an input resource.", dest); } } Restrict noexistRc = new Restrict(); noexistRc.add(NOT_EXISTS); noexistRc.add(rc); for (Resource r : noexistRc) { log(r + " does not exist.", Project.MSG_ERR); } Restrict result = new Restrict(); result.add(EXISTS); result.add(rc); return result; } private boolean isUpToDate(ResourceCollection c) { return dest != null && !forceOverwrite && c.stream().noneMatch(r -> SelectorUtils.isOutOfDate(r, dest, FILE_UTILS.getFileTimestampGranularity())); } /** * Treat empty nested text as no text. * * <p>Depending on the XML parser, addText may have been called * for "ignorable whitespace" as well.</p> */ private void sanitizeText() { if (textBuffer != null && textBuffer.toString().trim().isEmpty()) { textBuffer = null; } } private Reader getFilteredReader(Reader r) { if (filterChains == null) { return r; } ChainReaderHelper helper = new ChainReaderHelper(); helper.setBufferSize(BUFFER_SIZE); helper.setPrimaryReader(r); helper.setFilterChains(filterChains); helper.setProject(getProject()); //used to be a BufferedReader here, but we should be buffering lower: return helper.getAssembledReader(); } }
⏎ org/apache/tools/ant/taskdefs/Concat.java
Or download all of them as a single archive file:
File name: apache-ant-1.10.10-fyi.zip File size: 2392938 bytes Release date: 2021-04-17 Download
⇐ Download Apache Ant Source Package
2021-07-10, 111632👍, 0💬
Popular Posts:
JAX-WS is an API for building web services and clients. It is the next generation Web Services API r...
Jetty provides an HTTP server, HTTP client, and javax.servlet container. These components are open s...
JLayer is a library that decodes/plays/converts MPEG 1/2/2.5 Layer 1/2/3 (i.e. MP3) in real time for...
JSP(tm) Standard Tag Library 1.1 implementation - Jakarta Taglibs hosts the Standard Taglib 1.1, an ...
itextpdf.jar is a component in iText 5 Java library to provide core functionalities. iText Java libr...