aboutsummaryrefslogtreecommitdiffstats
path: root/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/filters/TokenFilter.java
diff options
context:
space:
mode:
Diffstat (limited to 'framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/filters/TokenFilter.java')
-rw-r--r--framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/filters/TokenFilter.java712
1 files changed, 0 insertions, 712 deletions
diff --git a/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/filters/TokenFilter.java b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/filters/TokenFilter.java
deleted file mode 100644
index ebad7602..00000000
--- a/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/filters/TokenFilter.java
+++ /dev/null
@@ -1,712 +0,0 @@
-/*
- * 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
- *
- * http://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.filters;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.util.Enumeration;
-import java.util.Vector;
-
-import org.apache.tools.ant.BuildException;
-import org.apache.tools.ant.ProjectComponent;
-import org.apache.tools.ant.types.RegularExpression;
-import org.apache.tools.ant.types.Substitution;
-import org.apache.tools.ant.util.LineTokenizer;
-import org.apache.tools.ant.util.StringUtils;
-import org.apache.tools.ant.util.Tokenizer;
-import org.apache.tools.ant.util.regexp.Regexp;
-import org.apache.tools.ant.util.regexp.RegexpUtil;
-
-/**
- * This splits up input into tokens and passes
- * the tokens to a sequence of filters.
- *
- * @since Ant 1.6
- * @see BaseFilterReader
- * @see ChainableReader
- * @see org.apache.tools.ant.DynamicConfigurator
- */
-public class TokenFilter extends BaseFilterReader
- implements ChainableReader {
- /**
- * string filters implement this interface
- */
- public interface Filter {
- /**
- * filter and/of modify a string
- *
- * @param string the string to filter
- * @return the modified string or null if the
- * string did not pass the filter
- */
- String filter(String string);
- }
-
-
- /** string filters */
- private Vector<Filter> filters = new Vector<Filter>();
- /** the tokenizer to use on the input stream */
- private Tokenizer tokenizer = null;
- /** the output token termination */
- private String delimOutput = null;
- /** the current string token from the input stream */
- private String line = null;
- /** the position in the current string token */
- private int linePos = 0;
-
- /**
- * Constructor for "dummy" instances.
- *
- * @see BaseFilterReader#BaseFilterReader()
- */
- public TokenFilter() {
- super();
- }
-
- /**
- * Creates a new filtered reader.
- *
- * @param in A Reader object providing the underlying stream.
- * Must not be <code>null</code>.
- */
- public TokenFilter(final Reader in) {
- super(in);
- }
-
-
- /**
- * Returns the next character in the filtered stream, only including
- * lines from the original stream which match all of the specified
- * regular expressions.
- *
- * @return the next character in the resulting stream, or -1
- * if the end of the resulting stream has been reached
- *
- * @exception IOException if the underlying stream throws an IOException
- * during reading
- */
-
- public int read() throws IOException {
- if (tokenizer == null) {
- tokenizer = new LineTokenizer();
- }
- while (line == null || line.length() == 0) {
- line = tokenizer.getToken(in);
- if (line == null) {
- return -1;
- }
- for (Enumeration<Filter> e = filters.elements(); e.hasMoreElements();) {
- Filter filter = e.nextElement();
- line = filter.filter(line);
- if (line == null) {
- break;
- }
- }
- linePos = 0;
- if (line != null) {
- if (tokenizer.getPostToken().length() != 0) {
- if (delimOutput != null) {
- line = line + delimOutput;
- } else {
- line = line + tokenizer.getPostToken();
- }
- }
- }
- }
- int ch = line.charAt(linePos);
- linePos++;
- if (linePos == line.length()) {
- line = null;
- }
- return ch;
- }
-
- /**
- * Creates a new TokenFilter using the passed in
- * Reader for instantiation.
- *
- * @param reader A Reader object providing the underlying stream.
- *
- * @return a new filter based on this configuration
- */
-
- public final Reader chain(final Reader reader) {
- TokenFilter newFilter = new TokenFilter(reader);
- newFilter.filters = filters;
- newFilter.tokenizer = tokenizer;
- newFilter.delimOutput = delimOutput;
- newFilter.setProject(getProject());
- return newFilter;
- }
-
- /**
- * set the output delimiter.
- * @param delimOutput replaces the delim string returned by the
- * tokenizer, if present.
- */
-
- public void setDelimOutput(String delimOutput) {
- this.delimOutput = resolveBackSlash(delimOutput);
- }
-
- // -----------------------------------------
- // Predefined tokenizers
- // -----------------------------------------
-
- /**
- * add a line tokenizer - this is the default.
- * @param tokenizer the line tokenizer
- */
-
- public void addLineTokenizer(LineTokenizer tokenizer) {
- add(tokenizer);
- }
-
- /**
- * add a string tokenizer
- * @param tokenizer the string tokenizer
- */
-
- public void addStringTokenizer(StringTokenizer tokenizer) {
- add(tokenizer);
- }
-
- /**
- * add a file tokenizer
- * @param tokenizer the file tokenizer
- */
- public void addFileTokenizer(FileTokenizer tokenizer) {
- add(tokenizer);
- }
-
- /**
- * add an arbitrary tokenizer
- * @param tokenizer the tokenizer to all, only one allowed
- */
-
- public void add(Tokenizer tokenizer) {
- if (this.tokenizer != null) {
- throw new BuildException("Only one tokenizer allowed");
- }
- this.tokenizer = tokenizer;
- }
-
- // -----------------------------------------
- // Predefined filters
- // -----------------------------------------
-
- /**
- * replace string filter
- * @param filter the replace string filter
- */
- public void addReplaceString(ReplaceString filter) {
- filters.addElement(filter);
- }
-
- /**
- * contains string filter
- * @param filter the contains string filter
- */
- public void addContainsString(ContainsString filter) {
- filters.addElement(filter);
- }
-
- /**
- * replace regex filter
- * @param filter the replace regex filter
- */
- public void addReplaceRegex(ReplaceRegex filter) {
- filters.addElement(filter);
- }
-
- /**
- * contains regex filter
- * @param filter the contains regex filter
- */
- public void addContainsRegex(ContainsRegex filter) {
- filters.addElement(filter);
- }
-
- /**
- * trim filter
- * @param filter the trim filter
- */
- public void addTrim(Trim filter) {
- filters.addElement(filter);
- }
-
- /**
- * ignore blank filter
- * @param filter the ignore blank filter
- */
- public void addIgnoreBlank(IgnoreBlank filter) {
- filters.addElement(filter);
- }
-
- /**
- * delete chars
- * @param filter the delete characters filter
- */
- public void addDeleteCharacters(DeleteCharacters filter) {
- filters.addElement(filter);
- }
-
- /**
- * Add an arbitrary filter
- * @param filter the filter to add
- */
- public void add(Filter filter) {
- filters.addElement(filter);
- }
-
-
- // --------------------------------------------
- //
- // Tokenizer Classes (impls moved to oata.util)
- //
- // --------------------------------------------
-
- /**
- * class to read the complete input into a string
- */
- public static class FileTokenizer
- extends org.apache.tools.ant.util.FileTokenizer {
- }
-
- /**
- * class to tokenize the input as areas separated
- * by white space, or by a specified list of
- * delim characters. Behaves like java.util.StringTokenizer.
- * if the stream starts with delim characters, the first
- * token will be an empty string (unless the treat delims
- * as tokens flag is set).
- */
- public static class StringTokenizer
- extends org.apache.tools.ant.util.StringTokenizer {
- }
-
- // --------------------------------------------
- //
- // Filter classes
- //
- // --------------------------------------------
-
- /**
- * Abstract class that converts derived filter classes into
- * ChainableReaderFilter's
- */
- public abstract static class ChainableReaderFilter extends ProjectComponent
- implements ChainableReader, Filter {
- private boolean byLine = true;
-
- /**
- * set whether to use filetokenizer or line tokenizer
- * @param byLine if true use a linetokenizer (default) otherwise
- * use a filetokenizer
- */
- public void setByLine(boolean byLine) {
- this.byLine = byLine;
- }
-
- /**
- * Chain a tokenfilter reader to a reader,
- *
- * @param reader the input reader object
- * @return the chained reader object
- */
- public Reader chain(Reader reader) {
- TokenFilter tokenFilter = new TokenFilter(reader);
- if (!byLine) {
- tokenFilter.add(new FileTokenizer());
- }
- tokenFilter.add(this);
- return tokenFilter;
- }
- }
-
- /**
- * Simple replace string filter.
- */
- public static class ReplaceString extends ChainableReaderFilter {
- private String from;
- private String to;
-
- /**
- * the from attribute
- *
- * @param from the string to replace
- */
- public void setFrom(String from) {
- this.from = from;
- }
-
- /**
- * the to attribute
- *
- * @param to the string to replace 'from' with
- */
- public void setTo(String to) {
- this.to = to;
- }
-
- /**
- * Filter a string 'line' replacing from with to
- * (Copy&amp;Paste from the Replace task)
- * @param line the string to be filtered
- * @return the filtered line
- */
- public String filter(String line) {
- if (from == null) {
- throw new BuildException("Missing from in stringreplace");
- }
- StringBuffer ret = new StringBuffer();
- int start = 0;
- int found = line.indexOf(from);
- while (found >= 0) {
- // write everything up to the from
- if (found > start) {
- ret.append(line.substring(start, found));
- }
-
- // write the replacement to
- if (to != null) {
- ret.append(to);
- }
-
- // search again
- start = found + from.length();
- found = line.indexOf(from, start);
- }
-
- // write the remaining characters
- if (line.length() > start) {
- ret.append(line.substring(start, line.length()));
- }
-
- return ret.toString();
- }
- }
-
- /**
- * Simple filter to filter lines contains strings
- */
- public static class ContainsString extends ProjectComponent
- implements Filter {
- private String contains;
-
- /**
- * the contains attribute
- * @param contains the string that the token should contain
- */
- public void setContains(String contains) {
- this.contains = contains;
- }
-
- /**
- * Filter strings that contain the contains attribute
- *
- * @param string the string to be filtered
- * @return null if the string does not contain "contains",
- * string otherwise
- */
- public String filter(String string) {
- if (contains == null) {
- throw new BuildException("Missing contains in containsstring");
- }
- if (string.indexOf(contains) > -1) {
- return string;
- }
- return null;
- }
- }
-
- /**
- * filter to replace regex.
- */
- public static class ReplaceRegex extends ChainableReaderFilter {
- private String from;
- private String to;
- private RegularExpression regularExpression;
- private Substitution substitution;
- private boolean initialized = false;
- private String flags = "";
- private int options;
- private Regexp regexp;
-
- /**
- * the from attribute
- * @param from the regex string
- */
- public void setPattern(String from) {
- this.from = from;
- }
- /**
- * the to attribute
- * @param to the replacement string
- */
- public void setReplace(String to) {
- this.to = to;
- }
-
- /**
- * @param flags the regex flags
- */
- public void setFlags(String flags) {
- this.flags = flags;
- }
-
- private void initialize() {
- if (initialized) {
- return;
- }
- options = convertRegexOptions(flags);
- if (from == null) {
- throw new BuildException("Missing pattern in replaceregex");
- }
- regularExpression = new RegularExpression();
- regularExpression.setPattern(from);
- regexp = regularExpression.getRegexp(getProject());
- if (to == null) {
- to = "";
- }
- substitution = new Substitution();
- substitution.setExpression(to);
- }
-
- /**
- * @param line the string to modify
- * @return the modified string
- */
- public String filter(String line) {
- initialize();
-
- if (!regexp.matches(line, options)) {
- return line;
- }
- return regexp.substitute(
- line, substitution.getExpression(getProject()), options);
- }
- }
-
- /**
- * filter to filter tokens matching regular expressions.
- */
- public static class ContainsRegex extends ChainableReaderFilter {
- private String from;
- private String to;
- private RegularExpression regularExpression;
- private Substitution substitution;
- private boolean initialized = false;
- private String flags = "";
- private int options;
- private Regexp regexp;
-
-
- /**
- * @param from the regex pattern
- */
- public void setPattern(String from) {
- this.from = from;
- }
-
- /**
- * @param to the replacement string
- */
- public void setReplace(String to) {
- this.to = to;
- }
-
- /**
- * @param flags the regex flags
- */
- public void setFlags(String flags) {
- this.flags = flags;
- }
-
- private void initialize() {
- if (initialized) {
- return;
- }
- options = convertRegexOptions(flags);
- if (from == null) {
- throw new BuildException("Missing from in containsregex");
- }
- regularExpression = new RegularExpression();
- regularExpression.setPattern(from);
- regexp = regularExpression.getRegexp(getProject());
- if (to == null) {
- return;
- }
- substitution = new Substitution();
- substitution.setExpression(to);
- }
-
- /**
- * apply regex and substitution on a string
- * @param string the string to apply filter on
- * @return the filtered string
- */
- public String filter(String string) {
- initialize();
- if (!regexp.matches(string, options)) {
- return null;
- }
- if (substitution == null) {
- return string;
- }
- return regexp.substitute(
- string, substitution.getExpression(getProject()), options);
- }
- }
-
- /** Filter to trim white space */
- public static class Trim extends ChainableReaderFilter {
- /**
- * @param line the string to be trimmed
- * @return the trimmed string
- */
- public String filter(String line) {
- return line.trim();
- }
- }
-
-
-
- /** Filter remove empty tokens */
- public static class IgnoreBlank extends ChainableReaderFilter {
- /**
- * @param line the line to modify
- * @return the trimmed line
- */
- public String filter(String line) {
- if (line.trim().length() == 0) {
- return null;
- }
- return line;
- }
- }
-
- /**
- * Filter to delete characters
- */
- public static class DeleteCharacters extends ProjectComponent
- implements Filter, ChainableReader {
- // Attributes
- /** the list of characters to remove from the input */
- private String deleteChars = "";
-
- /**
- * Set the list of characters to delete
- * @param deleteChars the list of characters
- */
- public void setChars(String deleteChars) {
- this.deleteChars = resolveBackSlash(deleteChars);
- }
-
- /**
- * remove characters from a string
- * @param string the string to remove the characters from
- * @return the converted string
- */
- public String filter(String string) {
- StringBuffer output = new StringBuffer(string.length());
- for (int i = 0; i < string.length(); ++i) {
- char ch = string.charAt(i);
- if (!(isDeleteCharacter(ch))) {
- output.append(ch);
- }
- }
- return output.toString();
- }
-
- /**
- * factory method to provide a reader that removes
- * the characters from a reader as part of a filter
- * chain
- * @param reader the reader object
- * @return the chained reader object
- */
- public Reader chain(Reader reader) {
- return new BaseFilterReader(reader) {
- /**
- * @return the next non delete character
- */
- public int read()
- throws IOException {
- while (true) {
- int c = in.read();
- if (c == -1) {
- return c;
- }
- if (!(isDeleteCharacter((char) c))) {
- return c;
- }
- }
- }
- };
- }
-
- /**
- * check if the character c is to be deleted
- *
- * @param c char to test
- * @return true if the supplied char is in the list to be stripped.
- */
- private boolean isDeleteCharacter(char c) {
- for (int d = 0; d < deleteChars.length(); ++d) {
- if (deleteChars.charAt(d) == c) {
- return true;
- }
- }
- return false;
- }
- }
-
- // --------------------------------------------------------
- // static utility methods - could be placed somewhere else
- // --------------------------------------------------------
-
- /**
- * xml does not do "c" like interpretation of strings.
- * i.e. \n\r\t etc.
- * this method processes \n, \r, \t, \f, \\
- * also subs \s with " \n\r\t\f"
- * a trailing '\' will be ignored
- *
- * @param input raw string with possible embedded '\'s
- * @return converted string
- */
- public static String resolveBackSlash(String input) {
- return StringUtils.resolveBackSlash(input);
- }
-
- /**
- * convert regex option flag characters to regex options
- * <ul>
- * <li>g - Regexp.REPLACE_ALL</li>
- * <li>i - Regexp.MATCH_CASE_INSENSITIVE</li>
- * <li>m - Regexp.MATCH_MULTILINE</li>
- * <li>s - Regexp.MATCH_SINGLELINE</li>
- * </ul>
- * @param flags the string containing the flags
- * @return the Regexp option bits
- */
- public static int convertRegexOptions(String flags) {
- return RegexpUtil.asOptions(flags);
- }
-}