diff options
Diffstat (limited to 'framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/types/optional/depend/DependScanner.java')
| -rw-r--r-- | framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/types/optional/depend/DependScanner.java | 225 |
1 files changed, 225 insertions, 0 deletions
diff --git a/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/types/optional/depend/DependScanner.java b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/types/optional/depend/DependScanner.java new file mode 100644 index 00000000..bb3cf54b --- /dev/null +++ b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/types/optional/depend/DependScanner.java @@ -0,0 +1,225 @@ +/* + * 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.types.optional.depend; + +import java.io.File; +import java.util.Enumeration; +import java.util.Hashtable; +import java.util.Vector; + +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.DirectoryScanner; +import org.apache.tools.ant.types.Path; +import org.apache.tools.ant.util.depend.DependencyAnalyzer; + + +/** + * DirectoryScanner for finding class dependencies. + */ +public class DependScanner extends DirectoryScanner { + /** + * The name of the analyzer to use by default. + */ + public static final String DEFAULT_ANALYZER_CLASS + = "org.apache.tools.ant.util.depend.bcel.FullAnalyzer"; + + /** + * The root classes to drive the search for dependent classes. + */ + private Vector<String> rootClasses; + + /** + * The names of the classes to include in the fileset. + */ + private Vector<String> included; + + private Vector<File> additionalBaseDirs = new Vector<File>(); + + /** + * The parent scanner which gives the basic set of files. Only files which + * are in this set and which can be reached from a root class will end + * up being included in the result set. + */ + private DirectoryScanner parentScanner; + + /** + * Create a DependScanner, using the given scanner to provide the basic + * set of files from which class files come. + * + * @param parentScanner the DirectoryScanner which returns the files from + * which class files must come. + */ + public DependScanner(DirectoryScanner parentScanner) { + this.parentScanner = parentScanner; + } + + /** + * Sets the root classes to be used to drive the scan. + * + * @param rootClasses the rootClasses to be used for this scan. + */ + public synchronized void setRootClasses(Vector<String> rootClasses) { + this.rootClasses = rootClasses; + } + + /** + * Get the names of the class files on which baseClass depends. + * + * @return the names of the files. + */ + public String[] getIncludedFiles() { + String[] files = new String[getIncludedFilesCount()]; + for (int i = 0; i < files.length; i++) { + files[i] = (String) included.elementAt(i); + } + return files; + } + + /** {@inheritDoc}. */ + public synchronized int getIncludedFilesCount() { + if (included == null) { + throw new IllegalStateException(); + } + return included.size(); + } + + /** + * Scans the base directory for files on which baseClass depends. + * + * @exception IllegalStateException when basedir was set incorrectly. + */ + public synchronized void scan() throws IllegalStateException { + included = new Vector<String>(); + String analyzerClassName = DEFAULT_ANALYZER_CLASS; + DependencyAnalyzer analyzer = null; + try { + Class<? extends DependencyAnalyzer> analyzerClass = Class.forName(analyzerClassName) + .asSubclass(DependencyAnalyzer.class); + analyzer = analyzerClass.newInstance(); + } catch (Exception e) { + throw new BuildException("Unable to load dependency analyzer: " + + analyzerClassName, e); + } + analyzer.addClassPath(new Path(null, basedir.getPath())); + for (Enumeration<File> e = additionalBaseDirs.elements(); e.hasMoreElements();) { + File additionalBaseDir = e.nextElement(); + analyzer.addClassPath(new Path(null, additionalBaseDir.getPath())); + } + + for (Enumeration<String> e = rootClasses.elements(); e.hasMoreElements();) { + String rootClass = e.nextElement(); + analyzer.addRootClass(rootClass); + } + Enumeration<String> e = analyzer.getClassDependencies(); + + String[] parentFiles = parentScanner.getIncludedFiles(); + Hashtable<String, String> parentSet = new Hashtable<String, String>(); + for (int i = 0; i < parentFiles.length; ++i) { + parentSet.put(parentFiles[i], parentFiles[i]); + } + while (e.hasMoreElements()) { + String classname = (String) e.nextElement(); + String filename = classname.replace('.', File.separatorChar); + filename = filename + ".class"; + File depFile = new File(basedir, filename); + if (depFile.exists() && parentSet.containsKey(filename)) { + // This is included + included.addElement(filename); + } + } + } + + /** + * @see DirectoryScanner#addDefaultExcludes + */ + public void addDefaultExcludes() { + } + + /** + * @see DirectoryScanner#getExcludedDirectories + */ + /** {@inheritDoc}. */ + public String[] getExcludedDirectories() { + return null; + } + + /** + * @see DirectoryScanner#getExcludedFiles + */ + /** {@inheritDoc}. */ + public String[] getExcludedFiles() { + return null; + } + + /** + * @see DirectoryScanner#getIncludedDirectories + */ + /** {@inheritDoc}. */ + public String[] getIncludedDirectories() { + return new String[0]; + } + + /** + * @see DirectoryScanner#getIncludedDirsCount + */ + /** {@inheritDoc}. */ + public int getIncludedDirsCount() { + return 0; + } + + /** + * @see DirectoryScanner#getNotIncludedDirectories + */ + /** {@inheritDoc}. */ + public String[] getNotIncludedDirectories() { + return null; + } + + /** + * @see DirectoryScanner#getNotIncludedFiles + */ + /** {@inheritDoc}. */ + public String[] getNotIncludedFiles() { + return null; + } + + /** + * @see DirectoryScanner#setExcludes + */ + /** {@inheritDoc}. */ + public void setExcludes(String[] excludes) { + } + + /** + * @see DirectoryScanner#setIncludes + */ + /** {@inheritDoc}. */ + public void setIncludes(String[] includes) { + } + + /** + * @see DirectoryScanner#setCaseSensitive + */ + /** {@inheritDoc}. */ + public void setCaseSensitive(boolean isCaseSensitive) { + } + + public void addBasedir(File baseDir) { + additionalBaseDirs.addElement(baseDir); + } +} |