| /*************************************************************************************************** |
| * Copyright (c) 2007 Eteration A.S. All rights reserved. This program and the |
| * accompanying materials are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: Naci Dai |
| * |
| **************************************************************************************************/ |
| |
| |
| package org.eclipse.jst.server.generic.internal.files; |
| |
| import java.io.File; |
| |
| /** |
| * |
| * DERIVED FROM APACHE ANT DIRECTORY SCANNER |
| * |
| * Class for scanning a directory for files/directories which match certain |
| * criteria. |
| * <p> |
| * These criteria consist of selectors and patterns which have been specified. |
| * With the selectors you can select which files you want to have included. |
| * Files which are not selected are excluded. With patterns you can include |
| * or exclude files based on their filename. |
| * <p> |
| * The idea is simple. A given directory is recursively scanned for all files |
| * and directories. Each file/directory is matched against a set of selectors, |
| * including special support for matching against filenames with include and |
| * and exclude patterns. Only files/directories which match at least one |
| * pattern of the include pattern list or other file selector, and don't match |
| * any pattern of the exclude pattern list or fail to match against a required |
| * selector will be placed in the list of files/directories found. |
| * <p> |
| * When no list of include patterns is supplied, "**" will be used, which |
| * means that everything will be matched. When no list of exclude patterns is |
| * supplied, an empty list is used, such that nothing will be excluded. When |
| * no selectors are supplied, none are applied. |
| * <p> |
| * The filename pattern matching is done as follows: |
| * The name to be matched is split up in path segments. A path segment is the |
| * name of a directory or file, which is bounded by |
| * <code>File.separator</code> ('/' under UNIX, '\' under Windows). |
| * For example, "abc/def/ghi/xyz.java" is split up in the segments "abc", |
| * "def","ghi" and "xyz.java". |
| * The same is done for the pattern against which should be matched. |
| * <p> |
| * The segments of the name and the pattern are then matched against each |
| * other. When '**' is used for a path segment in the pattern, it matches |
| * zero or more path segments of the name. |
| * <p> |
| * There is a special case regarding the use of <code>File.separator</code>s |
| * at the beginning of the pattern and the string to match:<br> |
| * When a pattern starts with a <code>File.separator</code>, the string |
| * to match must also start with a <code>File.separator</code>. |
| * When a pattern does not start with a <code>File.separator</code>, the |
| * string to match may not start with a <code>File.separator</code>. |
| * When one of these rules is not obeyed, the string will not |
| * match. |
| * <p> |
| * When a name path segment is matched against a pattern path segment, the |
| * following special characters can be used:<br> |
| * '*' matches zero or more characters<br> |
| * '?' matches one character. |
| * <p> |
| * Examples: |
| * <p> |
| * "**\*.class" matches all .class files/dirs in a directory tree. |
| * <p> |
| * "test\a??.java" matches all files/dirs which start with an 'a', then two |
| * more characters and then ".java", in a directory called test. |
| * <p> |
| * "**" matches everything in a directory tree. |
| * <p> |
| * "**\test\**\XYZ*" matches all files/dirs which start with "XYZ" and where |
| * there is a parent directory called test (e.g. "abc\test\def\ghi\XYZ123"). |
| * <p> |
| * Case sensitivity may be turned off if necessary. By default, it is |
| * turned on. |
| * <p> |
| * Example of usage: |
| * <pre> |
| * String[] includes = {"**\\*.class"}; |
| * String[] excludes = {"modules\\*\\**"}; |
| * ds.setIncludes(includes); |
| * ds.setExcludes(excludes); |
| * ds.setBasedir(new File("test")); |
| * ds.setCaseSensitive(true); |
| * ds.scan(); |
| * |
| * System.out.println("FILES:"); |
| * String[] files = ds.getIncludedFiles(); |
| * for (int i = 0; i < files.length; i++) { |
| * System.out.println(files[i]); |
| * } |
| * </pre> |
| * This will scan a directory called test for .class files, but excludes all |
| * files in all proper subdirectories of a directory called "modules" |
| * |
| */ |
| public class DirectoryScanner extends org.apache.tools.ant.DirectoryScanner { |
| |
| public DirectoryScanner() { |
| } |
| |
| public synchronized void setIncludes(String[] includes) { |
| super.setIncludes(includes); |
| } |
| public synchronized void setExcludes(String[] excludes) { |
| super.setExcludes(excludes); |
| } |
| public synchronized void setBasedir(File dir) { |
| super.setBasedir(dir); |
| } |
| public synchronized void setBasedir(String dir) { |
| super.setBasedir(dir); |
| } |
| |
| public void scan() throws IllegalStateException { |
| super.scan(); |
| } |
| public synchronized String[] getIncludedFiles() { |
| return super.getIncludedFiles(); |
| } |
| |
| } |