|
|
@@ -52,7 +52,7 @@ public class FileUtil { |
|
|
|
public static final File DEFAULT_PARENT = new File("."); // XXX user.dir? |
|
|
|
|
|
|
|
/** unmodifiable List of String source file suffixes (including leading ".") */ |
|
|
|
public static final List SOURCE_SUFFIXES = Collections.unmodifiableList(Arrays.asList(new String[] { ".java", ".aj" })); |
|
|
|
public static final List<String> SOURCE_SUFFIXES = Collections.unmodifiableList(Arrays.asList(new String[] { ".java", ".aj" })); |
|
|
|
|
|
|
|
public static final FileFilter ZIP_FILTER = new FileFilter() { |
|
|
|
public boolean accept(File file) { |
|
|
@@ -133,8 +133,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* @return 0 if file has no source suffix or the length of the suffix |
|
|
|
* otherwise |
|
|
|
* @return 0 if file has no source suffix or the length of the suffix otherwise |
|
|
|
*/ |
|
|
|
public static int sourceSuffixLength(File file) { |
|
|
|
return (null == file ? 0 : sourceSuffixLength(file.getPath())); |
|
|
@@ -146,8 +145,8 @@ public class FileUtil { |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
for (Iterator iter = SOURCE_SUFFIXES.iterator(); iter.hasNext();) { |
|
|
|
String suffix = (String) iter.next(); |
|
|
|
for (Iterator<String> iter = SOURCE_SUFFIXES.iterator(); iter.hasNext();) { |
|
|
|
String suffix = iter.next(); |
|
|
|
if (path.endsWith(suffix) || path.toLowerCase().endsWith(suffix)) { |
|
|
|
return suffix.length(); |
|
|
|
} |
|
|
@@ -196,8 +195,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* @throws IllegalArgumentException unless file is readable and not a |
|
|
|
* directory |
|
|
|
* @throws IllegalArgumentException unless file is readable and not a directory |
|
|
|
*/ |
|
|
|
public static void throwIaxUnlessCanWriteFile(File file, String label) { |
|
|
|
if (!canWriteFile(file)) { |
|
|
@@ -227,14 +225,14 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** @return array same length as input, with String paths */ |
|
|
|
public static String[] getPaths(List files) { |
|
|
|
public static String[] getPaths(List<File> files) { |
|
|
|
final int size = (null == files ? 0 : files.size()); |
|
|
|
if (0 == size) { |
|
|
|
return new String[0]; |
|
|
|
} |
|
|
|
String[] result = new String[size]; |
|
|
|
for (int i = 0; i < size; i++) { |
|
|
|
File file = (File) files.get(i); |
|
|
|
File file = files.get(i); |
|
|
|
if (null != file) { |
|
|
|
result[i] = file.getPath(); |
|
|
|
} |
|
|
@@ -243,16 +241,13 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Extract the name of a class from the path to its file. If the basedir is |
|
|
|
* null, then the class is assumed to be in the default package unless the |
|
|
|
* classFile has one of the top-level suffixes { com, org, java, javax } as |
|
|
|
* a parent directory. |
|
|
|
* Extract the name of a class from the path to its file. If the basedir is null, then the class is assumed to be in the default |
|
|
|
* package unless the classFile has one of the top-level suffixes { com, org, java, javax } as a parent directory. |
|
|
|
* |
|
|
|
* @param basedir the File of the base directory (prefix of classFile) |
|
|
|
* @param classFile the File of the class to extract the name for |
|
|
|
* @throws IllegalArgumentException if classFile is null or does not end |
|
|
|
* with ".class" or a non-null basedir is not a prefix of |
|
|
|
* classFile |
|
|
|
* @throws IllegalArgumentException if classFile is null or does not end with ".class" or a non-null basedir is not a prefix of |
|
|
|
* classFile |
|
|
|
*/ |
|
|
|
public static String fileToClassName(File basedir, File classFile) { |
|
|
|
LangUtil.throwIaxIfNull(classFile, "classFile"); |
|
|
@@ -290,12 +285,10 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Normalize path for comparisons by rendering absolute, clipping basedir |
|
|
|
* prefix, trimming and changing '\\' to '/' |
|
|
|
* Normalize path for comparisons by rendering absolute, clipping basedir prefix, trimming and changing '\\' to '/' |
|
|
|
* |
|
|
|
* @param file the File with the path to normalize |
|
|
|
* @param basedir the File for the prefix of the file to normalize - ignored |
|
|
|
* if null |
|
|
|
* @param basedir the File for the prefix of the file to normalize - ignored if null |
|
|
|
* @return "" if null or normalized path otherwise |
|
|
|
* @throws IllegalArgumentException if basedir is not a prefix of file |
|
|
|
*/ |
|
|
@@ -314,15 +307,12 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Render a set of files to String as a path by getting absolute paths of |
|
|
|
* each and delimiting with infix. |
|
|
|
* Render a set of files to String as a path by getting absolute paths of each and delimiting with infix. |
|
|
|
* |
|
|
|
* @param files the File[] to flatten - may be null or empty |
|
|
|
* @param infix the String delimiter internally between entries (if null, |
|
|
|
* then use File.pathSeparator). (alias to |
|
|
|
* <code>flatten(getAbsolutePaths(files), infix)</code> |
|
|
|
* @return String with absolute paths to entries in order, delimited with |
|
|
|
* infix |
|
|
|
* @param infix the String delimiter internally between entries (if null, then use File.pathSeparator). (alias to |
|
|
|
* <code>flatten(getAbsolutePaths(files), infix)</code> |
|
|
|
* @return String with absolute paths to entries in order, delimited with infix |
|
|
|
*/ |
|
|
|
public static String flatten(File[] files, String infix) { |
|
|
|
if (LangUtil.isEmpty(files)) { |
|
|
@@ -359,8 +349,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Normalize path for comparisons by rendering absolute trimming and |
|
|
|
* changing '\\' to '/' |
|
|
|
* Normalize path for comparisons by rendering absolute trimming and changing '\\' to '/' |
|
|
|
* |
|
|
|
* @return "" if null or normalized path otherwise |
|
|
|
*/ |
|
|
@@ -369,8 +358,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Weakly normalize path for comparisons by trimming and changing '\\' to |
|
|
|
* '/' |
|
|
|
* Weakly normalize path for comparisons by trimming and changing '\\' to '/' |
|
|
|
*/ |
|
|
|
public static String weakNormalize(String path) { |
|
|
|
if (null != path) { |
|
|
@@ -380,9 +368,8 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get best File for the first-readable path in input paths, treating |
|
|
|
* entries prefixed "sp:" as system property keys. Safe to call in static |
|
|
|
* initializers. |
|
|
|
* Get best File for the first-readable path in input paths, treating entries prefixed "sp:" as system property keys. Safe to |
|
|
|
* call in static initializers. |
|
|
|
* |
|
|
|
* @param paths the String[] of paths to check. |
|
|
|
* @return null if not found, or valid File otherwise |
|
|
@@ -483,8 +470,8 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Recursively delete some contents of dir, but not the dir itself. This |
|
|
|
* deletes any subdirectory which is empty after its files are deleted. |
|
|
|
* Recursively delete some contents of dir, but not the dir itself. This deletes any subdirectory which is empty after its files |
|
|
|
* are deleted. |
|
|
|
* |
|
|
|
* @return the total number of files deleted |
|
|
|
*/ |
|
|
@@ -493,9 +480,8 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Recursively delete some contents of dir, but not the dir itself. If |
|
|
|
* deleteEmptyDirs is true, this deletes any subdirectory which is empty |
|
|
|
* after its files are deleted. |
|
|
|
* Recursively delete some contents of dir, but not the dir itself. If deleteEmptyDirs is true, this deletes any subdirectory |
|
|
|
* which is empty after its files are deleted. |
|
|
|
* |
|
|
|
* @param dir the File directory (if a file, the the file is deleted) |
|
|
|
* @return the total number of files deleted |
|
|
@@ -543,17 +529,13 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Recursively copy files in fromDir (with any fromSuffix) to toDir, |
|
|
|
* replacing fromSuffix with toSuffix if any. This silently ignores dirs and |
|
|
|
* files that are not readable but throw IOException for directories that |
|
|
|
* are not writable. This does not clean out the original contents of toDir. |
|
|
|
* (subdirectories are not renamed per directory rules) |
|
|
|
* Recursively copy files in fromDir (with any fromSuffix) to toDir, replacing fromSuffix with toSuffix if any. This silently |
|
|
|
* ignores dirs and files that are not readable but throw IOException for directories that are not writable. This does not clean |
|
|
|
* out the original contents of toDir. (subdirectories are not renamed per directory rules) |
|
|
|
* |
|
|
|
* @param fromSuffix select files with this suffix - select all if null or |
|
|
|
* empty |
|
|
|
* @param toSuffix replace fromSuffix with toSuffix in the destination file |
|
|
|
* name - ignored if null or empty, appended to name if |
|
|
|
* fromSuffix is null or empty |
|
|
|
* @param fromSuffix select files with this suffix - select all if null or empty |
|
|
|
* @param toSuffix replace fromSuffix with toSuffix in the destination file name - ignored if null or empty, appended to name if |
|
|
|
* fromSuffix is null or empty |
|
|
|
* @return the total number of files copied |
|
|
|
*/ |
|
|
|
public static int copyDir(File fromDir, File toDir, final String fromSuffix, String toSuffix) throws IOException { |
|
|
@@ -596,18 +578,14 @@ public class FileUtil { |
|
|
|
// } |
|
|
|
|
|
|
|
/** |
|
|
|
* Recursively copy files in fromDir (with any fromSuffix) to toDir, |
|
|
|
* replacing fromSuffix with toSuffix if any. This silently ignores dirs and |
|
|
|
* files that are not readable but throw IOException for directories that |
|
|
|
* are not writable. This does not clean out the original contents of toDir. |
|
|
|
* (subdirectories are not renamed per directory rules) This calls any |
|
|
|
* delegate FilenameFilter to collect any selected file. |
|
|
|
* Recursively copy files in fromDir (with any fromSuffix) to toDir, replacing fromSuffix with toSuffix if any. This silently |
|
|
|
* ignores dirs and files that are not readable but throw IOException for directories that are not writable. This does not clean |
|
|
|
* out the original contents of toDir. (subdirectories are not renamed per directory rules) This calls any delegate |
|
|
|
* FilenameFilter to collect any selected file. |
|
|
|
* |
|
|
|
* @param fromSuffix select files with this suffix - select all if null or |
|
|
|
* empty |
|
|
|
* @param toSuffix replace fromSuffix with toSuffix in the destination file |
|
|
|
* name - ignored if null or empty, appended to name if |
|
|
|
* fromSuffix is null or empty |
|
|
|
* @param fromSuffix select files with this suffix - select all if null or empty |
|
|
|
* @param toSuffix replace fromSuffix with toSuffix in the destination file name - ignored if null or empty, appended to name if |
|
|
|
* fromSuffix is null or empty |
|
|
|
* @return the total number of files copied |
|
|
|
*/ |
|
|
|
public static int copyDir(File fromDir, File toDir, final String fromSuffix, final String toSuffix, final FileFilter delegate) |
|
|
@@ -662,15 +640,14 @@ public class FileUtil { |
|
|
|
/** |
|
|
|
* Recursively list files in srcDir. |
|
|
|
* |
|
|
|
* @return ArrayList with String paths of File under srcDir (relative to |
|
|
|
* srcDir) |
|
|
|
* @return ArrayList with String paths of File under srcDir (relative to srcDir) |
|
|
|
*/ |
|
|
|
public static String[] listFiles(File srcDir) { |
|
|
|
ArrayList result = new ArrayList(); |
|
|
|
ArrayList<String> result = new ArrayList<String>(); |
|
|
|
if ((null != srcDir) && srcDir.canRead()) { |
|
|
|
listFiles(srcDir, null, result); |
|
|
|
} |
|
|
|
return (String[]) result.toArray(new String[0]); |
|
|
|
return result.toArray(new String[0]); |
|
|
|
} |
|
|
|
|
|
|
|
public static final FileFilter aspectjSourceFileFilter = new FileFilter() { |
|
|
@@ -683,15 +660,14 @@ public class FileUtil { |
|
|
|
/** |
|
|
|
* Recursively list files in srcDir. |
|
|
|
* |
|
|
|
* @return ArrayList with String paths of File under srcDir (relative to |
|
|
|
* srcDir) |
|
|
|
* @return ArrayList with String paths of File under srcDir (relative to srcDir) |
|
|
|
*/ |
|
|
|
public static File[] listFiles(File srcDir, FileFilter fileFilter) { |
|
|
|
ArrayList result = new ArrayList(); |
|
|
|
ArrayList<File> result = new ArrayList<File>(); |
|
|
|
if ((null != srcDir) && srcDir.canRead()) { |
|
|
|
listFiles(srcDir, result, fileFilter); |
|
|
|
} |
|
|
|
return (File[]) result.toArray(new File[result.size()]); |
|
|
|
return result.toArray(new File[result.size()]); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
@@ -699,8 +675,8 @@ public class FileUtil { |
|
|
|
* |
|
|
|
* @return List of File objects |
|
|
|
*/ |
|
|
|
public static List listClassFiles(File dir) { |
|
|
|
ArrayList result = new ArrayList(); |
|
|
|
public static List<File> listClassFiles(File dir) { |
|
|
|
ArrayList<File> result = new ArrayList<File>(); |
|
|
|
if ((null != dir) && dir.canRead()) { |
|
|
|
listClassFiles(dir, result); |
|
|
|
} |
|
|
@@ -710,8 +686,7 @@ public class FileUtil { |
|
|
|
/** |
|
|
|
* Convert String[] paths to File[] as offset of base directory |
|
|
|
* |
|
|
|
* @param basedir the non-null File base directory for File to create with |
|
|
|
* paths |
|
|
|
* @param basedir the non-null File base directory for File to create with paths |
|
|
|
* @param paths the String[] of paths to create |
|
|
|
* @return File[] with same length as paths |
|
|
|
*/ |
|
|
@@ -722,11 +697,9 @@ public class FileUtil { |
|
|
|
/** |
|
|
|
* Convert String[] paths to File[] as offset of base directory |
|
|
|
* |
|
|
|
* @param basedir the non-null File base directory for File to create with |
|
|
|
* paths |
|
|
|
* @param basedir the non-null File base directory for File to create with paths |
|
|
|
* @param paths the String[] of paths to create |
|
|
|
* @param suffixes the String[] of suffixes to limit sources to - ignored if |
|
|
|
* null |
|
|
|
* @param suffixes the String[] of suffixes to limit sources to - ignored if null |
|
|
|
* @return File[] with same length as paths |
|
|
|
*/ |
|
|
|
public static File[] getBaseDirFiles(File basedir, String[] paths, String[] suffixes) { |
|
|
@@ -734,7 +707,7 @@ public class FileUtil { |
|
|
|
LangUtil.throwIaxIfNull(paths, "paths"); |
|
|
|
File[] result = null; |
|
|
|
if (!LangUtil.isEmpty(suffixes)) { |
|
|
|
ArrayList list = new ArrayList(); |
|
|
|
ArrayList<File> list = new ArrayList<File>(); |
|
|
|
for (int i = 0; i < paths.length; i++) { |
|
|
|
String path = paths[i]; |
|
|
|
for (int j = 0; j < suffixes.length; j++) { |
|
|
@@ -744,7 +717,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
result = (File[]) list.toArray(new File[0]); |
|
|
|
result = list.toArray(new File[0]); |
|
|
|
} else { |
|
|
|
result = new File[paths.length]; |
|
|
|
for (int i = 0; i < result.length; i++) { |
|
|
@@ -777,18 +750,14 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Copy files from source dir into destination directory, creating any |
|
|
|
* needed directories. This differs from copyDir in not being recursive; |
|
|
|
* each input with the source dir creates a full path. However, if the |
|
|
|
* source is a directory, it is copied as such. |
|
|
|
* Copy files from source dir into destination directory, creating any needed directories. This differs from copyDir in not |
|
|
|
* being recursive; each input with the source dir creates a full path. However, if the source is a directory, it is copied as |
|
|
|
* such. |
|
|
|
* |
|
|
|
* @param srcDir an existing, readable directory containing relativePaths |
|
|
|
* files |
|
|
|
* @param relativePaths a set of paths relative to srcDir to readable File |
|
|
|
* to copy |
|
|
|
* @param srcDir an existing, readable directory containing relativePaths files |
|
|
|
* @param relativePaths a set of paths relative to srcDir to readable File to copy |
|
|
|
* @param destDir an existing, writable directory to copy files to |
|
|
|
* @throws IllegalArgumentException if input invalid, IOException if |
|
|
|
* operations fail |
|
|
|
* @throws IllegalArgumentException if input invalid, IOException if operations fail |
|
|
|
*/ |
|
|
|
public static File[] copyFiles(File srcDir, String[] relativePaths, File destDir) throws IllegalArgumentException, IOException { |
|
|
|
final String[] paths = relativePaths; |
|
|
@@ -813,13 +782,10 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Copy fromFile to toFile, handling file-file, dir-dir, and file-dir |
|
|
|
* copies. |
|
|
|
* Copy fromFile to toFile, handling file-file, dir-dir, and file-dir copies. |
|
|
|
* |
|
|
|
* @param fromFile the File path of the file or directory to copy - must be |
|
|
|
* readable |
|
|
|
* @param toFile the File path of the target file or directory - must be |
|
|
|
* writable (will be created if it does not exist) |
|
|
|
* @param fromFile the File path of the file or directory to copy - must be readable |
|
|
|
* @param toFile the File path of the target file or directory - must be writable (will be created if it does not exist) |
|
|
|
*/ |
|
|
|
public static void copyFile(File fromFile, File toFile) throws IOException { |
|
|
|
LangUtil.throwIaxIfNull(fromFile, "fromFile"); |
|
|
@@ -855,14 +821,12 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Ensure that the parent directory to path can be written. If the path has |
|
|
|
* a null parent, DEFAULT_PARENT is tested. If the path parent does not |
|
|
|
* exist, this tries to create it. |
|
|
|
* Ensure that the parent directory to path can be written. If the path has a null parent, DEFAULT_PARENT is tested. If the path |
|
|
|
* parent does not exist, this tries to create it. |
|
|
|
* |
|
|
|
* @param path the File path whose parent should be writable |
|
|
|
* @return the File path of the writable parent directory |
|
|
|
* @throws IllegalArgumentException if parent cannot be written or path is |
|
|
|
* null. |
|
|
|
* @throws IllegalArgumentException if parent cannot be written or path is null. |
|
|
|
*/ |
|
|
|
public static File ensureParentWritable(File path) { |
|
|
|
LangUtil.throwIaxIfNull(path, "path"); |
|
|
@@ -955,8 +919,8 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Make a new temporary directory in the same directory that the system uses |
|
|
|
* for temporary files, or if that files, in the current directory. |
|
|
|
* Make a new temporary directory in the same directory that the system uses for temporary files, or if that files, in the |
|
|
|
* current directory. |
|
|
|
* |
|
|
|
* @param name the preferred (simple) name of the directory - may be null. |
|
|
|
* @return File of an existing new temp dir, or null if unable to create |
|
|
@@ -995,8 +959,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get URL for a File. This appends "/" for directories. prints errors to |
|
|
|
* System.err |
|
|
|
* Get URL for a File. This appends "/" for directories. prints errors to System.err |
|
|
|
* |
|
|
|
* @param file the File to convert to URL (not null) |
|
|
|
*/ |
|
|
@@ -1019,8 +982,8 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Write contents to file, returning null on success or error message |
|
|
|
* otherwise. This tries to make any necessary parent directories first. |
|
|
|
* Write contents to file, returning null on success or error message otherwise. This tries to make any necessary parent |
|
|
|
* directories first. |
|
|
|
* |
|
|
|
* @param file the File to write (not null) |
|
|
|
* @param contents the String to write (use "" if null) |
|
|
@@ -1059,8 +1022,9 @@ public class FileUtil { |
|
|
|
public static boolean[] readBooleanArray(DataInputStream s) throws IOException { |
|
|
|
int len = s.readInt(); |
|
|
|
boolean[] ret = new boolean[len]; |
|
|
|
for (int i = 0; i < len; i++) |
|
|
|
for (int i = 0; i < len; i++) { |
|
|
|
ret[i] = s.readBoolean(); |
|
|
|
} |
|
|
|
return ret; |
|
|
|
} |
|
|
|
|
|
|
@@ -1070,8 +1034,9 @@ public class FileUtil { |
|
|
|
public static void writeBooleanArray(boolean[] a, DataOutputStream s) throws IOException { |
|
|
|
int len = a.length; |
|
|
|
s.writeInt(len); |
|
|
|
for (int i = 0; i < len; i++) |
|
|
|
for (int i = 0; i < len; i++) { |
|
|
|
s.writeBoolean(a[i]); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
@@ -1080,8 +1045,9 @@ public class FileUtil { |
|
|
|
public static int[] readIntArray(DataInputStream s) throws IOException { |
|
|
|
int len = s.readInt(); |
|
|
|
int[] ret = new int[len]; |
|
|
|
for (int i = 0; i < len; i++) |
|
|
|
for (int i = 0; i < len; i++) { |
|
|
|
ret[i] = s.readInt(); |
|
|
|
} |
|
|
|
return ret; |
|
|
|
} |
|
|
|
|
|
|
@@ -1091,8 +1057,9 @@ public class FileUtil { |
|
|
|
public static void writeIntArray(int[] a, DataOutputStream s) throws IOException { |
|
|
|
int len = a.length; |
|
|
|
s.writeInt(len); |
|
|
|
for (int i = 0; i < len; i++) |
|
|
|
for (int i = 0; i < len; i++) { |
|
|
|
s.writeInt(a[i]); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
@@ -1101,8 +1068,9 @@ public class FileUtil { |
|
|
|
public static String[] readStringArray(DataInputStream s) throws IOException { |
|
|
|
int len = s.readInt(); |
|
|
|
String[] ret = new String[len]; |
|
|
|
for (int i = 0; i < len; i++) |
|
|
|
for (int i = 0; i < len; i++) { |
|
|
|
ret[i] = s.readUTF(); |
|
|
|
} |
|
|
|
return ret; |
|
|
|
} |
|
|
|
|
|
|
@@ -1116,8 +1084,9 @@ public class FileUtil { |
|
|
|
} |
|
|
|
int len = a.length; |
|
|
|
s.writeInt(len); |
|
|
|
for (int i = 0; i < len; i++) |
|
|
|
for (int i = 0; i < len; i++) { |
|
|
|
s.writeUTF(a[i]); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
@@ -1128,8 +1097,9 @@ public class FileUtil { |
|
|
|
StringBuffer b = new StringBuffer(); |
|
|
|
while (true) { |
|
|
|
int ch = r.read(); |
|
|
|
if (ch == -1) |
|
|
|
if (ch == -1) { |
|
|
|
break; |
|
|
|
} |
|
|
|
b.append((char) ch); |
|
|
|
} |
|
|
|
r.close(); |
|
|
@@ -1173,8 +1143,9 @@ public class FileUtil { |
|
|
|
|
|
|
|
while (true) { |
|
|
|
int nRead = inStream.read(ba, readSoFar, size - readSoFar); |
|
|
|
if (nRead == -1) |
|
|
|
if (nRead == -1) { |
|
|
|
break; |
|
|
|
} |
|
|
|
readSoFar += nRead; |
|
|
|
if (readSoFar == size) { |
|
|
|
int newSize = size * 2; |
|
|
@@ -1245,25 +1216,22 @@ public class FileUtil { |
|
|
|
// } |
|
|
|
|
|
|
|
/** |
|
|
|
* Do line-based search for literal text in source files, returning |
|
|
|
* file:line where found. |
|
|
|
* Do line-based search for literal text in source files, returning file:line where found. |
|
|
|
* |
|
|
|
* @param sought the String text to seek in the file |
|
|
|
* @param sources the List of String paths to the source files |
|
|
|
* @param listAll if false, only list first match in file |
|
|
|
* @param errorSink the PrintStream to print any errors to (one per line) |
|
|
|
* (use null to silently ignore errors) |
|
|
|
* @return List of String of the form file:line for each found entry (never |
|
|
|
* null, might be empty) |
|
|
|
* @param errorSink the PrintStream to print any errors to (one per line) (use null to silently ignore errors) |
|
|
|
* @return List of String of the form file:line for each found entry (never null, might be empty) |
|
|
|
*/ |
|
|
|
// OPTIMIZE only used by tests? move it out |
|
|
|
public static List lineSeek(String sought, List sources, boolean listAll, PrintStream errorSink) { |
|
|
|
public static List<String> lineSeek(String sought, List<String> sources, boolean listAll, PrintStream errorSink) { |
|
|
|
if (LangUtil.isEmpty(sought) || LangUtil.isEmpty(sources)) { |
|
|
|
return Collections.EMPTY_LIST; |
|
|
|
return Collections.emptyList(); |
|
|
|
} |
|
|
|
ArrayList result = new ArrayList(); |
|
|
|
for (Iterator iter = sources.iterator(); iter.hasNext();) { |
|
|
|
String path = (String) iter.next(); |
|
|
|
ArrayList<String> result = new ArrayList<String>(); |
|
|
|
for (Iterator<String> iter = sources.iterator(); iter.hasNext();) { |
|
|
|
String path = iter.next(); |
|
|
|
String error = lineSeek(sought, path, listAll, result); |
|
|
|
if ((null != error) && (null != errorSink)) { |
|
|
|
errorSink.println(error); |
|
|
@@ -1273,19 +1241,17 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Do line-based search for literal text in source file, returning line |
|
|
|
* where found as a String in the form {sourcePath}:line:column submitted to |
|
|
|
* the collecting parameter sink. Any error is rendered to String and |
|
|
|
* returned as the result. |
|
|
|
* Do line-based search for literal text in source file, returning line where found as a String in the form |
|
|
|
* {sourcePath}:line:column submitted to the collecting parameter sink. Any error is rendered to String and returned as the |
|
|
|
* result. |
|
|
|
* |
|
|
|
* @param sought the String text to seek in the file |
|
|
|
* @param sources the List of String paths to the source files |
|
|
|
* @param listAll if false, only list first match in file |
|
|
|
* @param List sink the List for String entries of the form |
|
|
|
* {sourcePath}:line:column |
|
|
|
* @param List sink the List for String entries of the form {sourcePath}:line:column |
|
|
|
* @return String error if any, or add String entries to sink |
|
|
|
*/ |
|
|
|
public static String lineSeek(String sought, String sourcePath, boolean listAll, ArrayList sink) { |
|
|
|
public static String lineSeek(String sought, String sourcePath, boolean listAll, ArrayList<String> sink) { |
|
|
|
if (LangUtil.isEmpty(sought) || LangUtil.isEmpty(sourcePath)) { |
|
|
|
return "nothing sought"; |
|
|
|
} |
|
|
@@ -1316,8 +1282,9 @@ public class FileUtil { |
|
|
|
return LangUtil.unqualifiedClassName(e) + " reading " + sourcePath + ":" + lineNum; |
|
|
|
} finally { |
|
|
|
try { |
|
|
|
if (null != fin) |
|
|
|
if (null != fin) { |
|
|
|
fin.close(); |
|
|
|
} |
|
|
|
} catch (IOException e) { |
|
|
|
} // ignore |
|
|
|
} |
|
|
@@ -1326,17 +1293,17 @@ public class FileUtil { |
|
|
|
|
|
|
|
public static BufferedOutputStream makeOutputStream(File file) throws FileNotFoundException { |
|
|
|
File parent = file.getParentFile(); |
|
|
|
if (parent != null) |
|
|
|
if (parent != null) { |
|
|
|
parent.mkdirs(); |
|
|
|
} |
|
|
|
return new BufferedOutputStream(new FileOutputStream(file)); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Sleep until after the last last-modified stamp from the files. |
|
|
|
* |
|
|
|
* @param files the File[] of files to inspect for last modified times (this |
|
|
|
* ignores null or empty files array and null or non-existing |
|
|
|
* components of files array) |
|
|
|
* @param files the File[] of files to inspect for last modified times (this ignores null or empty files array and null or |
|
|
|
* non-existing components of files array) |
|
|
|
* @return true if succeeded without 100 interrupts |
|
|
|
*/ |
|
|
|
public static boolean sleepPastFinalModifiedTime(File[] files) { |
|
|
@@ -1357,7 +1324,7 @@ public class FileUtil { |
|
|
|
return LangUtil.sleepUntil(++delayUntil); |
|
|
|
} |
|
|
|
|
|
|
|
private static void listClassFiles(final File baseDir, ArrayList result) { |
|
|
|
private static void listClassFiles(final File baseDir, ArrayList<File> result) { |
|
|
|
File[] files = baseDir.listFiles(); |
|
|
|
for (int i = 0; i < files.length; i++) { |
|
|
|
File f = files[i]; |
|
|
@@ -1371,7 +1338,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
private static void listFiles(final File baseDir, ArrayList result, FileFilter filter) { |
|
|
|
private static void listFiles(final File baseDir, ArrayList<File> result, FileFilter filter) { |
|
|
|
File[] files = baseDir.listFiles(); |
|
|
|
// hack https://bugs.eclipse.org/bugs/show_bug.cgi?id=48650 |
|
|
|
final boolean skipCVS = (!PERMIT_CVS && (filter == aspectjSourceFileFilter)); |
|
|
@@ -1386,8 +1353,9 @@ public class FileUtil { |
|
|
|
} |
|
|
|
listFiles(f, result, filter); |
|
|
|
} else { |
|
|
|
if (filter.accept(f)) |
|
|
|
if (filter.accept(f)) { |
|
|
|
result.add(f); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
@@ -1397,7 +1365,7 @@ public class FileUtil { |
|
|
|
return ((null != input) && (-1 == input.indexOf(File.pathSeparator))); |
|
|
|
} |
|
|
|
|
|
|
|
private static void listFiles(final File baseDir, String dir, ArrayList result) { |
|
|
|
private static void listFiles(final File baseDir, String dir, ArrayList<String> result) { |
|
|
|
final String dirPrefix = (null == dir ? "" : dir + "/"); |
|
|
|
final File dirFile = (null == dir ? baseDir : new File(baseDir.getPath() + "/" + dir)); |
|
|
|
final String[] files = dirFile.list(); |
|
|
@@ -1415,8 +1383,8 @@ public class FileUtil { |
|
|
|
private FileUtil() { |
|
|
|
} |
|
|
|
|
|
|
|
public static List makeClasspath(URL[] urls) { |
|
|
|
List ret = new LinkedList(); |
|
|
|
public static List<String> makeClasspath(URL[] urls) { |
|
|
|
List<String> ret = new LinkedList<String>(); |
|
|
|
if (urls != null) { |
|
|
|
for (int i = 0; i < urls.length; i++) { |
|
|
|
ret.add(urls[i].getPath()); |
|
|
@@ -1426,8 +1394,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* A pipe when run reads from an input stream to an output stream, |
|
|
|
* optionally sleeping between reads. |
|
|
|
* A pipe when run reads from an input stream to an output stream, optionally sleeping between reads. |
|
|
|
* |
|
|
|
* @see #copyStream(InputStream, OutputStream) |
|
|
|
*/ |
|
|
@@ -1446,8 +1413,7 @@ public class FileUtil { |
|
|
|
private final boolean closeOutput; |
|
|
|
|
|
|
|
/** |
|
|
|
* If true, then continue processing stream until no characters are |
|
|
|
* returned when halting. |
|
|
|
* If true, then continue processing stream until no characters are returned when halting. |
|
|
|
*/ |
|
|
|
private boolean finishStream; |
|
|
|
|
|
|
@@ -1466,10 +1432,8 @@ public class FileUtil { |
|
|
|
/** |
|
|
|
* @param in the InputStream source to read |
|
|
|
* @param out the OutputStream sink to write |
|
|
|
* @param tryClosingStreams if true, then try closing both streams when |
|
|
|
* done |
|
|
|
* @param sleep milliseconds to delay between reads (pinned to 0..1 |
|
|
|
* minute) |
|
|
|
* @param tryClosingStreams if true, then try closing both streams when done |
|
|
|
* @param sleep milliseconds to delay between reads (pinned to 0..1 minute) |
|
|
|
*/ |
|
|
|
Pipe(InputStream in, OutputStream out, long sleep, boolean closeInput, boolean closeOutput) { |
|
|
|
LangUtil.throwIaxIfNull(in, "in"); |
|
|
@@ -1486,8 +1450,7 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Run the pipe. This halts on the first Throwable thrown or when a read |
|
|
|
* returns -1 (for end-of-file) or on demand. |
|
|
|
* Run the pipe. This halts on the first Throwable thrown or when a read returns -1 (for end-of-file) or on demand. |
|
|
|
*/ |
|
|
|
public void run() { |
|
|
|
totalWritten = 0; |
|
|
@@ -1546,10 +1509,8 @@ public class FileUtil { |
|
|
|
* Tell the pipe to halt the next time it gains control. |
|
|
|
* |
|
|
|
* @param wait if true, this waits synchronously until pipe is done |
|
|
|
* @param finishStream if true, then continue until a read from the |
|
|
|
* input stream returns no bytes, then halt. |
|
|
|
* @return true if <code>run()</code> will return the next time it gains |
|
|
|
* control |
|
|
|
* @param finishStream if true, then continue until a read from the input stream returns no bytes, then halt. |
|
|
|
* @return true if <code>run()</code> will return the next time it gains control |
|
|
|
*/ |
|
|
|
public boolean halt(boolean wait, boolean finishStream) { |
|
|
|
if (!halt) { |
|
|
@@ -1583,10 +1544,8 @@ public class FileUtil { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* This is called when the pipe is completing. This implementation does |
|
|
|
* nothing. Subclasses implement this to get notice. Note that |
|
|
|
* halt(true, true) might or might not have completed before this method |
|
|
|
* is called. |
|
|
|
* This is called when the pipe is completing. This implementation does nothing. Subclasses implement this to get notice. |
|
|
|
* Note that halt(true, true) might or might not have completed before this method is called. |
|
|
|
*/ |
|
|
|
protected void completing(long totalWritten, Throwable thrown) { |
|
|
|
} |