/*
* 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.uima.util;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Random;
/**
* Some utilities for handling files.
*
*
*/
public class FileUtils {
/**
* Get a list of all files in a directory. Optionally, get files in subdirectories as well.
*
* @param directory
* The directory for which to get the files.
* @param getRecursive
* Should we get files from subdirectories?
* @return ArrayList A list of <code>File</code> objects. <code>null</code> if
* <code>directory</code> does not exist, or is not a directory.
*/
public static final ArrayList<File> getFiles(File directory, boolean getRecursive) {
if (!directory.exists() || !directory.isDirectory()) {
return null;
}
ArrayList<File> fileList = new ArrayList<File>();
for (File file : directory.listFiles()) {
if (file.isDirectory()) {
if (getRecursive) {
fileList.addAll(getFiles(file, getRecursive));
}
} else {
fileList.add(file);
}
}
return fileList;
}
/**
* Get a list of all files in a directory, ignoring subdirectories.
*
* @param directory
* The directory for which to get the files.
* @return ArrayList A list of <code>File</code> objects. <code>null</code> if
* <code>directory</code> does not exist, or is not a directory.
*/
public static final ArrayList<File> getFiles(File directory) {
return getFiles(directory, false);
}
/**
* Get a list of all subdirectories in a directory, ignoring regular files.
*
* @param directory
* The directory for which to get the subdirectories.
* @return ArrayList A list of <code>File</code> objects. <code>null</code> if
* <code>directory</code> does not exist, or is not a directory.
*/
public static final ArrayList<File> getSubDirs(File directory) {
if (!directory.exists() || !directory.isDirectory()) {
return null;
}
ArrayList<File> dirList = new ArrayList<File>();
for (File file : directory.listFiles()) {
if (file.isDirectory()) {
dirList.add(file);
}
}
return dirList;
}
/**
* Read a bufferedReader into a string, using the default platform encoding.
*
* @param reader
* to be read in
* @return String The contents of the stream.
* @throws IOException
* Various I/O errors.
*/
public static String reader2String(Reader reader) throws IOException {
StringBuffer strBuffer = new StringBuffer();
char[] buf = new char[10000];
int charsRead;
try {
while ((charsRead = reader.read(buf)) >= 0) {
strBuffer.append(buf, 0, charsRead);
}
} finally {
reader.close();
}
return strBuffer.toString();
}
/**
* Read the contents of a file into a string, using the default platform encoding.
*
* @param file
* The file to be read in.
* @return String The contents of the file.
* @throws IOException
* Various I/O errors.
*/
public static String file2String(File file) throws IOException {
return reader2String(new FileReader(file));
}
/**
* Read the contents of a file into a string using a specific character encoding.
*
* @param file
* The input file.
* @param fileEncoding
* The character encoding of the file (see your Java documentation for supported
* encodings).
* @return String The contents of the file.
* @throws IOException
* Various I/O errors.
*/
public static String file2String(File file, String fileEncoding) throws IOException {
if (fileEncoding == null) { // use default
return file2String(file);
}
return reader2String(new InputStreamReader(new FileInputStream(file), fileEncoding));
}
/**
* Write a string to a file, using platform encoding. If the file exists, it is overwritten.
*
* @param fileContents
* The file contents.
* @param file
* The file to save to.
* @throws IOException
* If for any reason the file can't be written.
*/
public static void saveString2File(String fileContents, File file) throws IOException {
saveString2File(fileContents, file, Charset.defaultCharset().name());
}
/**
* Write a string to a file using the specified encoding. If the file exists, it is overwritten.
*
* @param s
* The file contents.
* @param file
* The file to save to.
* @param encoding
* The character encoding to use.
* @throws IOException
* If for any reason the file can't be written.
*/
public static void saveString2File(String s, File file, String encoding) throws IOException {
BufferedWriter writer = null;
try {
writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), encoding));
writer.write(s);
writer.close();
} finally {
if (writer != null) {
writer.close();
}
}
}
/**
* Delete all files in a directory (not recursive).
*
* @param directory
* The directory that contains the files to be deleted.
*/
public static final void deleteAllFiles(File directory) {
File[] fileList = directory.listFiles();
// If file does not exist, or is not a directory, do nothing.
if (fileList == null) {
return;
}
File file;
for (int i = 0; i < fileList.length; i++) {
file = fileList[i];
if (file.isFile()) {
file.delete();
}
}
}
/**
* Recursively delete possibly non-empty directory or file.
*
* @param file
* The file or directory to be deleted.
* @return <code>true</code> iff the file/directory could be deleted.
*/
public static final boolean deleteRecursive(File file) {
if (!file.exists()) {
return false;
}
boolean rc = true;
if (file.isDirectory()) {
File[] fileList = file.listFiles();
for (int i = 0; i < fileList.length; i++) {
rc &= deleteRecursive(fileList[i]);
}
}
rc &= file.delete();
return rc;
}
/**
* Create a new directory. The parent directory must exist.
*
* @param directory
* The directory to be created.
* @return boolean Will fail if directory already exists, or File.mkdir() returns
* <code>false</code>.
*/
public static final boolean mkdir(File directory) {
// Check if directory already exists. The documentation is silent on
// what
// could actually cause File.mkdir() to fail.
if (directory.exists()) {
return false;
}
return directory.mkdir();
}
/**
* Create a temporary directory using random numbers as name suffixes.
*
* @param parent
* Where the directory is created.
* @param prefix
* Prefix of the directory names to be created.
* @return A file object corresponding to the newly created dir, or <code>null</code> if none
* could be created for some reason (e.g., if the parent is not writable).
*/
public static final File createTempDir(File parent, String prefix) {
Random rand = new Random();
File tempDir;
while (true) {
tempDir = new File(parent, prefix + rand.nextInt());
if (!tempDir.exists()) {
if (tempDir.mkdirs()) {
tempDir.deleteOnExit();
return tempDir;
}
return null;
}
}
}
public static final File createTempFile(String prefix, String suffix, File tempDir)
throws IOException {
File file = File.createTempFile(prefix, suffix, tempDir);
file.deleteOnExit();
return file;
}
/**
* Copy file <code>file</code> to location <code>dir</code>. This method will not fail silently.
* Anything that prevents the copy from happening will be treated as an error condition. If the
* method does not throw an exception, the copy was successful.
*
* <p>
* <b>Note: </b> this is a completely brain-dead implementation of file copy. The complete file is
* read into memory before it is copied. If you need something more sophisticated for copying
* large files, feel free to add your improvements.
*
* @param file
* The file to copy.
* @param dir
* The destination directory.
* @throws IOException
* For various reason: if <code>file</code> does not exist or is not readable, if the
* destination directory does not exist or isn't a directory, or if the file can't be
* copied for any reason.
*/
public static final void copyFile(File file, File dir) throws IOException {
if (!file.exists() || !file.canRead()) {
throw new IOException("File does not exist or is not readable: " + file.getAbsolutePath());
}
if (!dir.exists() || !dir.isDirectory()) {
throw new IOException("Destination does not exist or is not a directory: "
+ dir.getAbsolutePath());
}
File outFile = new File(dir, file.getName());
if (outFile.exists() && !outFile.canWrite()) {
throw new IOException("Can't write output file: " + outFile);
}
byte[] bytes = new byte[(int) file.length()];
FileInputStream is = null;
FileOutputStream os = null;
try {
is = new FileInputStream(file);
os = new FileOutputStream(outFile);
while (true) {
int count = is.read(bytes);
if (0 > count) {
break;
}
os.write(bytes, 0, count);
}
} finally {
if (null != is) {
is.close();
}
if (null != os) {
os.close();
}
}
}
/**
* Finds a relative path to a given file, relative to a specified directory.
*
* @param file
* file that the relative path should resolve to
* @param relativeToDir
* directory that the path should be relative to
* @return a relative path. This always uses / as the separator character.
*/
public static String findRelativePath(File file, File relativeToDir) throws IOException {
String canonicalFile = file.getCanonicalPath();
String canonicalRelTo = relativeToDir.getCanonicalPath();
String[] filePathComponents = getPathComponents(canonicalFile);
String[] relToPathComponents = getPathComponents(canonicalRelTo);
int i = 0;
while (i < filePathComponents.length && i < relToPathComponents.length
&& filePathComponents[i].equals(relToPathComponents[i])) {
i++;
}
StringBuffer buf = new StringBuffer();
for (int j = i; j < relToPathComponents.length; j++) {
buf.append("../");
}
for (int j = i; j < filePathComponents.length - 1; j++) {
buf.append(filePathComponents[j]).append('/');
}
buf.append(filePathComponents[filePathComponents.length - 1]);
return buf.toString();
}
/**
* Splits a path into components using the OS file separator character. This can be used on the
* results of File.getCanonicalPath().
*
* @param canonicalPath
* a file path that uses the OS file separator character
* @return an array of strings, one for each component of the path
*/
public static String[] getPathComponents(String canonicalPath) {
String regex = File.separator;
if (regex.equals("\\"))
regex = "\\\\";
return canonicalPath.split(regex);
}
}